apache/skywalking

This system is the Apache SkyWalking Observability Analysis Platform (OAP) server, a backend service that ingests, analyzes, and stores distributed telemetry data including traces, metrics, logs, and events. It provides comprehensive observability capabilities by supporting diverse data sources such as OpenTelemetry, Zipkin, and iOS telemetry, while offering advanced analysis features like AI-driven anomaly detection, GenAI evaluation, and continuous profiling via eBPF and async-profiler. The platform enables dynamic rule management for log and metric analysis, cluster coordination through various backends, and flexible data export to systems like Kafka and gRPC endpoints.

99 changes.

This period focused on the foundational restructuring of the SkyWalking OAP server into a modular, plugin-based architecture, introducing a new core framework for component lifecycle management. It established the v11 infrastructure with native support for OTLP, Envoy v3, and multiple cluster coordination backends, while refactoring the storage, alarm, and metrics processing pipelines for improved performance and extensibility.

79 changes.

This period focused on significantly expanding the OAP server's data ingestion and analysis capabilities by introducing new receivers for browser telemetry, events, Zabbix metrics, and native OTLP traces. The core metrics engine was enhanced with histogram, percentile, and latest-value aggregations, while the storage layer adopted a new buffered concurrency model and unified endpoint/instance traffic models. Additionally, the infrastructure was modernized with a new OAL V2 engine, dynamic configuration support via Kubernetes ConfigMaps, and a rewritten Elasticsearch client.

97 changes.

This period focused on integrating eBPF-based continuous profiling and expanding agentless telemetry ingestion through new receiver plugins. It also involved a major architectural shift by migrating the Log and Metric Analysis Languages to a high-performance ANTLR4 and Javassist compilation engine, enabling runtime rule hot-updates and live debugging capabilities.

Introduces a new \aws-firehose-receiver\ module that allows SkyWalking to ingest metrics from AWS Kinesis Firehose in OpenTelemetry format. The receiver exposes an HTTP POST endpoint at \/aws/firehose/metrics\ that accepts JSON payloads containing base64-encoded, delimited OpenTelemetry protocol buffers. It validates an optional \X-Amz-Firehose-Access-Key\ header for authentication and converts the incoming Firehose-specific OTLP metric structures into the standard OTLP v1 format for processing by the existing metric pipeline.

oap-server/server-receiver-plugin/aws-firehose-receiver · high confidence

The OAP server now supports Apollo as a dynamic configuration center. This change introduces the Apollo configuration module, allowing users to configure the Apollo connection details (such as meta address, app ID, cluster, and environment) via the \ApolloConfigurationCenterSettings\. The implementation includes a watcher register that listens for changes in both single keys and grouped namespaces, enabling real-time configuration updates without restarting the server.

oap-server/server-configuration/configuration-apollo/src/main · high confidence

The OA server now includes a new \receiver-async-profiler\ plugin that enables the ingestion of Java Flight Recorder (JFR) profiling data collected by Async Profiler. This feature introduces a gRPC service handler that accepts profiling streams and supports two collection modes: in-memory parsing via \AsyncProfilerByteBufCollectionObserver\ (default) and file-based parsing via \AsyncProfilerFileCollectionObserver\, configurable through the \memoryParserEnabled\ setting. The plugin parses incoming JFR files, extracts frame trees, and forwards the resulting \JFRProfilingData\ to the core source receiver for storage and analysis.

oap-server/server-receiver-plugin/skywalking-async-profiler-receiver-plugin · high confidence

The OAP server now includes a new CLR receiver plugin that enables ingestion of .NET Common Language Runtime metrics. This plugin registers a gRPC handler to receive CLR metric collections from agents and dispatches them into three specific metric types: CPU usage, Garbage Collection statistics (Gen0/1/2 collection counts and heap memory), and Thread pool availability (worker and completion port threads). It also loads a dedicated OAL script to define the corresponding metrics and indicators for analysis.

oap-server/server-receiver-plugin/skywalking-clr-receiver-plugin · high confidence

The OAP server now includes a new \configuration-discovery\ receiver plugin that allows agents to query and receive dynamic configuration updates (such as trace sampling rates and ignored paths) via gRPC. This plugin introduces a new module that registers a gRPC handler to serve configuration requests, a watcher to manage configuration changes from the dynamic configuration service, and a YAML-based reader to parse agent-specific settings. Administrators can control whether the server uses SHA512 message digests to detect configuration changes or always returns the latest configuration via the \disableMessageDigest\ setting.

oap-server/server-receiver-plugin/configuration-discovery-receiver-plugin · high confidence

Users can now configure SkyWalking to retrieve dynamic configurations from HashiCorp Consul. This change introduces the Consul configuration module, allowing administrators to specify the Consul host, port, and ACL token in the settings. The implementation supports both single-node and multi-node Consul clusters, enables watching for configuration changes via key-value listeners, and includes support for grouped configuration keys.

oap-server/server-configuration/configuration-consul/src/main · high confidence

The receiver-proto module now includes the protobuf definitions for Envoy AccessLogService and MetricsService v3 APIs, alongside the OpenTelemetry Collector v1 services for traces, metrics, and logs. This addition enables the server to natively receive and process telemetry data using these standardized protocols. Additionally, a Java utility class (OTLPValues) is introduced to standardize how OTLP attribute values are rendered as strings, ensuring consistent indexing and searchability across the Zipkin conversion, native span index, and TraceQL plugin.

oap-server/server-receiver-plugin/receiver-proto · high confidence

The trace profiling module now supports Go applications in addition to Java. This change introduces a new \ProfileLanguageType\ enum to distinguish between Java and Go profiles, updates the \ProfileThreadSnapshotRecord\ to store the language type, and adds a \GoProfileAnalyzer\ to parse and analyze Go pprof data. The main \ProfileAnalyzer\ has been updated to attempt Java analysis first, then fall back to Go analysis if no Java data is found, allowing users to view flame graphs for Go services.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/trace · high confidence

Introduces a new Kubernetes-based cluster manager for the SkyWalking OAP server, allowing instances to discover and coordinate with each other within a Kubernetes cluster. The plugin registers a \ClusterModuleKubernetesProvider\ that uses the Fabric8 Kubernetes client to watch Pods matching a configurable label selector and namespace. It identifies cluster members by their Pod IP and port, supports self-discovery via a configurable environment variable for the Pod UID, and ensures only Ready, Running Pods are included in the cluster view to maintain stability.

oap-server/server-cluster-plugin/cluster-kubernetes-plugin/src/main · high confidence

The OAP server now supports Nacos as a backend for dynamic configuration management. Users can configure the Nacos server address, port, namespace, and group, and choose between username/password or AccessKey/SecretKey authentication. The implementation registers listeners to automatically detect and apply configuration changes in real-time.

oap-server/server-configuration/configuration-nacos/src/main · high confidence

Introduces a new receiver plugin that allows the OAP server to ingest metrics from Zabbix agents. The plugin registers a new module (receiver-zabbix) and provider that starts a TCP server (default port 10051) to listen for Zabbix protocol traffic. It handles both active checks and agent data pushes, converting incoming Zabbix metrics into the OAP MeterSystem using configurable YAML rule files.

oap-server/server-receiver-plugin/skywalking-zabbix-receiver-plugin · high confidence

The server now includes core source model classes (ZipkinSpan, ZipkinService, ZipkinServiceSpan, and ZipkinServiceRelation) in the zipkin source package. These classes define the data structures and serialization logic required to ingest and process Zipkin-format trace data, enabling the platform to accept and analyze traces from Zipkin-compatible clients.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/zipkin/source · high confidence

Users can now configure the OAP server to fetch dynamic configuration from an Apache Zookeeper cluster. This change introduces the Zookeeper configuration module, which includes a provider (\ZookeeperConfigurationProvider\) and a watcher register (\ZookeeperConfigWatcherRegister\) that connects to Zookeeper using Curator, reads configuration items and groups from a specified namespace, and handles null data safely to prevent runtime errors.

oap-server/server-configuration/configuration-etcd/src/main/java, oap-server/server-configuration/configuration-zookeeper/src/main · high confidence

The OAP server now captures and stores browser error logs. This change introduces the \BrowserErrorLogRecord\ data model and its dispatcher, which routes incoming \BrowserErrorLog\ source events into the storage pipeline. The record includes fields for unique ID, service ID, service version, page path, timestamp, error category, and binary data, enabling users to analyze frontend errors within SkyWalking.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/browser/manual/errorlog · high confidence

The server now includes storage models and dispatchers for eBPF process profiling data. This change introduces new record classes (EBPFProfilingDataRecord, EBPFProfilingScheduleRecord, EBPFProfilingTaskRecord) and dispatcher components to ingest, store, and manage eBPF profiling tasks, schedules, and stack data. It also adds supporting enums for profiling target types (On-CPU, Off-CPU, Network) and stack types (Kernel, User), enabling the backend to persist and process continuous profiling information from eBPF agents.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/ebpf/storage · high confidence

The etcd cluster plugin is now available, allowing SkyWalking OAP servers to use etcd as the underlying storage for cluster node registration, discovery, and health checking. This new module introduces configuration options for etcd endpoints, service names, namespaces, and authentication, and registers the etcd coordinator to handle cluster membership and remote instance queries.

oap-server/server-cluster-plugin/cluster-etcd-plugin/src/main · high confidence

Introduces a new gRPC module that allows the SkyWalking OAP server to fetch dynamic configurations from a remote configuration center. This includes a new protobuf service definition for configuration requests and responses, a provider to initialize the gRPC client, and a watcher register that polls for config changes using UUID-based change detection to minimize data transfer.

oap-server/server-configuration/grpc-configuration-sync/src/main · high confidence

The server now collects and stores instance-level traffic metrics via a new \InstanceTraffic\ model and a set of dispatchers (for standard, Kubernetes, TCP, and Cilium/Hubble service instances). This enables visibility into instance activity and last-seen timestamps, supporting features like on-demand Pod logs and instance health monitoring.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/instance · high confidence

The library-util module now includes a set of new utility classes to support configuration parsing, file monitoring, and data handling. This includes a file change detection mechanism via MultipleFilesChangeMonitor, a connection string parser in ConnectUtils, and a property placeholder helper for resolving configuration values. Additional utilities cover boolean conversions, collection checks, protobuf JSON serialization, and resource loading.

oap-server/server-library/library-util · high confidence

The \library-pprof-parser\ module now provides the core infrastructure to ingest, parse, and analyze Go pprof profile data. This includes a \PprofParser\ to decode gzip-compressed protobuf profiles into internal frame trees, a \FrameTreeBuilder\ to aggregate sample data into hierarchical call stacks, and a \PprofSegmentParser\ to extract distributed tracing context (such as segment IDs, trace IDs, and span IDs) from profile labels. A \profile.proto\ definition is also included to support the parsing of the standard pprof format.

oap-server/server-library/library-pprof-parser · high confidence

The SkyWalking OAP server now includes a new receiver plugin that enables the ingestion of pprof profiling data. This feature introduces a gRPC service handler that accepts profiling streams, supporting both in-memory buffering and temporary file storage based on the \memoryParserEnabled\ configuration. Administrators can control the maximum accepted file size via the \pprofMaxSize\ setting (defaulting to 30 MB), and the plugin automatically parses the incoming data into frame trees for storage and analysis.

oap-server/server-receiver-plugin/skywalking-pprof-receiver-plugin · high confidence

The server now captures detailed process-to-process communication metrics by introducing \ProcessRelationClientSideMetrics\ and \ProcessRelationServerSideMetrics\ classes, along with a \ProcessRelationDispatcher\ to route incoming \ProcessRelation\ source data. This enables the service topology view to distinguish between client-side and server-side interactions at the process level, storing these relations with specific index names (\process\_relation\_client\_side\ and \process\_relation\_server\_side\) and supporting storage in both ElasticSearch and BanyanDB.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/relation/process · high confidence

The server now processes Cilium endpoint relation data to populate server-side endpoint call metrics. New dispatcher classes (EndpointCallRelationDispatcher and HubbleEndpointCallRelationDispatcher) route EndpointRelation and CiliumEndpointRelation sources into a new EndpointRelationServerSideMetrics entity, enabling visibility into service-to-endpoint call relationships specifically for Cilium-based network traffic monitoring.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/relation/endpoint · high confidence

The server now captures and stores service-to-service call relations with support for multiple component IDs and TLS status tracking. New dispatcher classes (ServiceCallRelationDispatcher, TCPServiceCallRelationDispatcher, K8SServiceCallRelationDispatcher, HubbleServiceCallRelationDispatcher) route relation data from standard, TCP, Kubernetes, and Cilium sources into new metrics entities (ServiceRelationServerSideMetrics, ServiceRelationClientSideMetrics). These metrics record source/destination service IDs, a list of component IDs, and TLS mode (MTLS/TLS/NON-TLS) as component IDs 142/130, enabling users to observe service dependencies, component diversity, and encryption status in topology and metrics views.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/relation/service · high confidence

The server now captures and stores service-to-service instance communication topology by introducing dedicated metrics classes (ServiceInstanceRelationClientSideMetrics and ServiceInstanceRelationServerSideMetrics) and their corresponding dispatchers for standard, Kubernetes, TCP, and Cilium/Hubble sources. These metrics record source and destination service/instance IDs with a 250-character ID length limit, enabling users to visualize and analyze direct instance-level dependencies and call patterns across different networking environments.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/relation/instance · high confidence

The server now supports aggregating slow database statement records by service dimension. This change introduces new data models (TopNServiceDatabaseStatement, TopNDatabaseStatement) and their corresponding dispatchers to capture and process slow SQL, MongoDB, and Redis commands at the service level, enabling users to identify and analyze the most impactful database operations per service.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/database · high confidence

The server now analyzes cache-related spans to provide metrics and identify slow commands for cache services. This change introduces new data models (TopNCacheReadCommand and TopNCacheWriteCommand) and a dispatcher (CacheSlowAccessDispatcher) to process slow access events, enabling visibility into the performance of cache read and write operations.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/cache · high confidence

Introduces a new standalone cluster implementation for the SkyWalking OAP server, enabling single-node deployments without requiring an external cluster coordinator. The \ClusterModuleStandaloneProvider\ registers the \StandaloneManager\ to implement cluster coordination services, which manages cluster state in memory and notifies watchers upon startup.

oap-server/server-cluster-plugin/cluster-standalone-plugin/src/main · high confidence

The server now supports two new meter aggregation functions: \sumPerMin\ and \sumPerMinLabeled\. These functions accumulate metric values over time and calculate the average per minute. The \sumPerMin\ function handles simple numeric values, while \sumPerMinLabeled\ supports labeled metrics using a DataTable structure, allowing for more granular metric breakdowns. Both functions include support for time-bucketing (hourly/daily) and serialization for remote data handling.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/sumpermin · high confidence

The server now includes \LatestFunction\ and \LatestLabeledFunction\ meter functions, enabling the collection and storage of the most recent metric value for an entity rather than aggregated statistics. \LatestFunction\ stores a single long value, while \LatestLabeledFunction\ supports complex labeled data via \DataTable\. Both implementations include serialization, deserialization, and time-bucketing logic (hourly/daily) and are configured for storage in BanyanDB (using \SeriesID\) and ElasticSearch (with doc values enabled).

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/latest · high confidence

The server-core module introduces new data model classes (GroupBy, KeyValues, and Where) within the org.apache.skywalking.oap.server.core.query.sql package to support structured SQL query construction. These classes provide the foundational structures for defining grouping columns, key-value pairs for filtering, and where-clause conditions, enabling more complex metric and topology queries.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/sql · high confidence

The server now supports max and min aggregation for meter metrics, introducing four new function types: max, min, maxLabeled, and minLabeled. These implementations allow users to track the highest and lowest recorded values for metrics, including support for labeled (DataTable) values, and are integrated into the existing down-sampling and storage pipeline.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/max, oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/min · high confidence

The server core now includes dedicated DAO interfaces for persisting runtime-managed MAL/LAL rules and UI dashboard templates. RuntimeRuleManagementDAO provides upsert and delete operations for rule files to ensure correct persistence semantics across backends, while UITemplateManagementDAO exposes CRUD methods for managing dashboard configurations. These interfaces enable the backend to store and retrieve these management entities, supporting the hot-update of runtime rules and the management of UI templates.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/management · high confidence

A new dispatcher class, BrowserAppSingleVersionTrafficDispatcher, has been added to route browser telemetry data into the core instance metrics pipeline. This change ensures that browser application traffic is processed and aggregated alongside other service instance data, enabling unified visibility into service health and performance from browser sources.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/browser/manual/instance · high confidence

The OAP server now processes browser telemetry data by routing it through a new BrowserAppTrafficDispatcher. This component takes incoming BrowserAppTraffic sources and forwards them as ServiceTraffic metrics with the layer explicitly set to BROWSER, ensuring that browser performance data is integrated into the standard service-level metrics pipeline.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/browser/manual/service · high confidence

The server now provides a unified CommandService in the core module to generate and dispatch profiling commands to agents. This service creates specific command objects for async profiling, pprof (Go agents), eBPF network profiling (including dynamic sampling strategies and extension configs), and continuous profiling policies, ensuring that task details like triggers, durations, and sampling rules are correctly serialized and sent downstream.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/command · high confidence

The server now supports loading and applying logging configuration changes dynamically. A new LoggingConfigWatcher monitors configuration updates (including deletions) and applies them to the active Log4j context without requiring a restart, while supporting classes (OapConfiguration, OapConfigurationFactory) ensure proper handling of XML-based log4j configurations.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/logging · high confidence

The envoy-metrics-receiver-plugin has been reorganized to support Envoy Access Log Service (ALS) and Metrics Service API v3. This includes new gRPC handlers (AccessLogServiceGRPCHandlerV3, MetricServiceGRPCHandlerV3) that delegate to v2 implementations, enabling compatibility with newer Envoy versions. The plugin now integrates with the LAL (Log Analysis Language) framework via EnvoyHTTPLALSourceTypeProvider, allowing HTTP access log entries to be processed through the LAL compiler for direct proto getter calls. Configuration is centralized in EnvoyMetricReceiverConfig, supporting separate HTTP and TCP analysis chains, MAL rule loading, and Istio ServiceEntry namespace filtering. The module provider registers both v2 and v3 handlers, along with a SatelliteAccessLogServiceGRPCHandlerV3 for satellite-specific access log processing.

oap-server/server-receiver-plugin/envoy-metrics-receiver-plugin · high confidence

The etcd configuration module is now properly registered with the SkyWalking server runtime. A new service provider file has been added to declare the EtcdConfigurationProvider, ensuring the system can locate and initialize the etcd-based configuration support during startup.

oap-server/server-configuration/configuration-etcd/src/main/resources · high confidence

This change introduces the core provider logic for the SkyWalking exporter module, establishing the wiring for metric, trace, and log export services. It registers a gRPC-based exporter for metrics and Kafka-based exporters for traces and logs, controlled by configuration flags in ExporterSetting (e.g., enableGRPCMetrics, enableKafkaTrace). The provider also includes a MetricFormatter that resolves entity names for various scopes (service, instance, endpoint, and their relations) to ensure exported data is human-readable.

oap-server/exporter/src/main/java/org/apache/skywalking/oap/server/exporter/provider · high confidence

The Consul cluster plugin now provides a complete implementation for managing SkyWalking OAP server clusters using HashiCorp Consul. This includes a new configuration model (\ClusterModuleConsulConfig\) supporting service name, host/port, internal communication endpoints, and ACL tokens, alongside a provider (\ClusterModuleConsulProvider\) that initializes the Consul client and registers the \ClusterCoordinator\ service. The coordinator (\ConsulCoordinator\) handles service registration with health checks, discovers healthy remote nodes, and maintains cluster state via Consul's caching mechanism, enabling users to leverage Consul as the backend for cluster discovery and health monitoring.

oap-server/server-cluster-plugin/cluster-consul-plugin/src/main · high confidence

Establishes the foundational project structure and configuration files for Apache SkyWalking, including the main README, CONTRIBUTING guidelines, and the CLAUDE.md AI assistant guide. Adds standard Apache artifacts such as the LICENSE, NOTICE, and HEADER files, alongside build tooling like the Maven Wrapper (mvnw/mvnw.cmd) and a Makefile for building backend and Docker images. Configures development standards through .asf.yaml (GitHub merge settings, branch protection, Dependabot disablement), .licenserc.yaml (license header enforcement), codeStyle.xml, and lombok.config, while also defining .gitmodules for protocol submodules and .dlc.json for dead-link checking.

(repo-wide) · high confidence

This change introduces the \skywalking-mesh-receiver-plugin\, a new module that enables the OAP server to receive and process service mesh telemetry data. It registers a gRPC handler (\MeshGRPCHandler\) to accept \ServiceMeshMetrics\ streams, which are then dispatched by \TelemetryDataDispatcher\ into internal source objects for HTTP and TCP metrics. The plugin also loads the \mesh.oal\ analysis definition to support mesh-specific data processing and registers itself as the \service-mesh\ module within the OAP server lifecycle.

oap-server/server-receiver-plugin/skywalking-mesh-receiver-plugin · high confidence

The server core now includes internal classes (DebuggingSpan, DebuggingTrace, DebuggingTraceContext) that enable tracing of OAP internal query execution. This infrastructure allows developers to capture and inspect the execution flow of internal operations, such as BanyanDB debugging traces, by creating spans and tracking their timing and hierarchy during query processing.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/type/debugging · high confidence

The new \ai-evaluation\ module enables automated evaluation of GenAI observability data using an external LLM judge. It introduces a configurable pipeline that samples spans (via \AIEvaluationSpanListener\), extracts input/output messages, and sends them to an OpenAI-compatible provider for scoring. Users can configure the judge endpoint, model, and sampling rate in \ai-evaluation.yml\, and define custom evaluation tasks with specific instructions and value types. The module resolves evaluation levels (e.g., 'excellent', 'fail') based on configurable score ranges and boolean outcomes, providing a structured way to assess AI model performance directly within the OAP server.

oap-server/analyzer/ai-evaluation · high confidence

A new \ai-pipeline\ module has been added to the OAP server to support AI-driven observability features. This module introduces an HTTP URI recognition service that synchronizes pattern dictionaries and feeds raw URI data to a remote AI server via gRPC, enabling automatic endpoint grouping. Additionally, it provides a baseline query service that connects to a baseline prediction server to retrieve predicted metric values (including single and labeled values) for anomaly detection, with local caching to optimize performance. The module is configured via \AIPipelineConfig\ for server addresses and ports, and includes the necessary gRPC protocol definitions and service implementations.

oap-server/ai-pipeline · high confidence

The OAP server now includes a new 'ai-agent-conversation' module that ingests and stores long-lived AI agent conversations (Session Data and Session Flow files) landed by the AI Sessionizer. This module provides HTTP endpoints to retrieve conversation views and individual provider body files, and exposes a query service for retrieving conversation data. It includes configuration options for controlling read windows, response sizes, and file size limits, and supports a 'none' provider to disable the feature entirely if needed.

oap-server/analyzer/ai-agent-conversation · high confidence

A new partitioned, self-draining queue library (BatchQueue) is added to replace the previous DataCarrier implementation in the metrics pipeline. It provides type-based dispatch, adaptive partitioning that scales with registered handlers, configurable thread policies (including ioBound for blocking consumers), and a throughput-weighted drain balancer to optimize load distribution. This change improves back-pressure handling and reduces noisy logging in the health checker and batch queue components.

oap-server/server-library/library-batch-queue · high confidence

This change adds the core data structures for the new Event concept within the server-core query layer. It introduces the \Event\ class, which now includes a \layer\ field to distinguish event scope, and defines \EventType\ (Normal, Error) and \Source\ (service, instance, endpoint) to provide richer context for each event. Additionally, \EventQueryCondition\ is added to enable filtering events by these attributes, and \Events\ serves as the container for query results, laying the groundwork for event collection and retrieval.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/type/event · high confidence

This change adds the \gen-ai-analyzer\ module to the OAP server, enabling virtual GenAI monitoring by extracting metrics from both native OTLP and Zipkin traces. The module registers a \GenAISpanListener\ that processes spans to identify GenAI providers and models (using prefix matching and aliases), calculates estimated token costs based on configurable pricing, and emits \GenAIMetrics\ sources. It includes configuration loading for provider/model definitions and an OAL definition for the virtual GenAI layer, allowing users to observe GenAI usage and costs alongside standard service traces.

oap-server/analyzer/gen-ai-analyzer · high confidence

The core module now includes a new data model, GenAIEvaluationRecord, and a corresponding GenAIEvaluationRecordQueryService. This enables the OAP server to persist and query GenAI evaluation results, including metrics like scores, boolean values, and string-based reasons, linked to trace IDs and span indices. This change supports the new GenAI observability capabilities by providing the backend storage and query infrastructure for evaluation data.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core · high confidence

The OAP server now includes a new \kafka-fetcher-plugin\ that enables the ingestion of telemetry data (traces, metrics, logs, profiling, and service management) from Apache Kafka. This plugin registers dedicated handlers for each data type, automatically creates missing Kafka topics with configurable partitions and replication factors, and processes incoming records using a configurable thread pool. It supports both native protobuf and JSON log formats, allows topic name customization via configuration, and integrates with the existing analyzer modules for data processing.

oap-server/server-fetcher-plugin/kafka-fetcher-plugin · high confidence

The Log Analysis Language (LAL) engine has been replaced with a V2 implementation that compiles LAL rules into Java classes using ANTLR4 and Javassist at startup, improving performance and type safety over the previous runtime. This change introduces a new DSL execution model where rules are compiled into {@code LalExpression} objects, managed via a new {@code DSL} class that handles input/output type routing and filter specifications. A significant addition is the integration of a live debugger for LAL rules, allowing operators to inspect rule execution stages (text, parser, extractor, output) and drop reasons in real-time via {@code GateHolder} and {@code LALDebug} probes. The engine now supports structured metadata decoupling via {@code LogMetadata}, JSON parsing from text bodies, and runtime rule hot-updates with isolated class loading.

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/dsl · high confidence

The Log Analysis Language (LAL) compiler has been replaced with a new v2 engine that uses ANTLR4 for parsing DSL scripts into an AST and Javassist for generating Java bytecode at runtime. This change introduces new compiler components (LALScriptParser, LALClassGenerator, LALBlockCodegen, LALValueCodegen, LALDefCodegen) that handle parsing, AST modeling, and code generation for LAL blocks (extractor, sink, sampler) and expressions. The new compiler supports local variables via the \def\ keyword with type inference and casting, JSON/YAML/text parser blocks, and unified arithmetic operators with JLS-style type promotion. Generated classes are now defined in a dedicated runtime package and can be loaded via custom ClassLoaders to support runtime rule hot-updates.

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler · high confidence

This change adds a new LogQL query plugin that exposes HTTP endpoints compatible with the Loki API, enabling users to query logs using LogQL syntax. The implementation includes ANTLR grammar definitions for the LogQL lexer and parser, a module provider that starts an HTTP server, and API handlers for label discovery and log range queries. This allows users to integrate with tools that support the Loki protocol for log retrieval.

oap-server/server-query-plugin/promql-plugin · high confidence

The agent-analyzer module now processes meter data using the MeterProcessService, which implements the MalConverterRegistry to allow runtime-rule hot-swapping of meter-analyzer-config rules without restarting the OAP server. This replaces the previous OAL-based meter analysis with a new MAL (Meter Analysis Language) engine that compiles and installs rules at startup and supports live updates via the runtime-rule plugin. The module also registers new services for segment parsing and meter processing, and includes configuration watchers for dynamic thresholds (DB, cache read/write) and trace sampling policies.

oap-server/analyzer/agent-analyzer/src/main · high confidence

The \oap-server/mqe-rt\ module now provides the runtime execution engine for the Metrics Query Engine (MQE). This change adds the core visitor infrastructure and operation implementations that allow users to query metrics and traces using a new expression language. Specifically, it enables arithmetic and comparison binary operations, logical boolean operators (AND/OR), aggregation functions (AVG, SUM, MAX, MIN, COUNT, LATEST), and sorting capabilities. It also introduces specialized functions for debugging and data inspection, including \view\_as\_seq\ for prioritized metric listing, \is\_present\ to check metric existence, and \top\_n\_of\ for merging top-N queries. The runtime integrates with the \ai-pipeline\ module to support baseline queries and includes tracing support for debugging SkyWalking and Zipkin trace queries.

oap-server/mqe-rt · high confidence

The server now defines a dedicated \NetworkAddressAlias\ metric entity to track network address aliases, including the associated service and instance identifiers. This change adds the core data model (\NetworkAddressAlias.java\) with storage annotations for BanyanDB indexing and a setup dispatcher (\NetworkAddressAliasSetupDispatcher.java\) that routes incoming \NetworkAddressAliasSetup\ source events into the metrics stream processor, enabling the system to persist and query these alias relationships.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/networkalias · high confidence

The Prometheus telemetry module now provides a new HTTP-based exporter for exposing metrics in Prometheus format. This implementation includes a configurable HTTP server (defaulting to port 1234) that supports optional SSL/TLS encryption via configurable key and certificate paths. The module registers Counter, Gauge, and Histogram metric types, automatically attaching backend instance labels, and exposes JVM memory metrics (heap and direct) alongside standard application metrics.

oap-server/server-telemetry/telemetry-prometheus · high confidence

The server now introduces a new \ServiceTraffic\ metrics model and a set of dedicated dispatchers (\ServiceTrafficDispatcher\, \K8SServiceTrafficDispatcher\, \HubbleServiceTrafficDispatcher\, \TCPServiceTrafficDispatcher\, \ServiceMetaDispatcher\) to process traffic data from various sources including standard services, Kubernetes services, Cilium/Hubble, and TCP. These dispatchers normalize incoming source data into the new \ServiceTraffic\ entity, which tracks service name, layer, and group information, enabling more granular and consistent service traffic monitoring across different infrastructure types.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/service · high confidence

Added the TopN abstract record class in the core analysis module to support TopN data structures. This class defines fields for latency, trace ID, entity ID, and timestamp, and applies storage-specific annotations such as @ElasticSearch.EnableDocValues and @BanyanDB.EnableSort to enable efficient sorting and aggregation in the underlying storage backends.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/topn · high confidence

This change introduces the TraceQL plugin, providing a new HTTP server that implements the Grafana Tempo API for querying traces. The plugin adds ANTLR grammar files (TraceQLLexer.g4, TraceQLParser.g4) to define the TraceQL query language, enabling users to filter traces using attributes, scopes, and operators. It includes handlers for Zipkin, SkyWalking, and native OTLP data sources, allowing users to query traces stored in these formats via a unified Tempo-compatible interface. The plugin also adds configuration options for enabling specific data sources, setting REST endpoints, and enabling TLS with certificate hot-reload. Additionally, it introduces converters and matchers for transforming and filtering OTLP and SkyWalking trace data to align with Tempo's response format and search behavior.

oap-server/server-query-plugin/traceql-plugin · high confidence

This change adds the \query-zipkin\ module to the SkyWalking OAP server, providing a new HTTP REST API for querying Zipkin-format traces. The plugin introduces a dedicated HTTP server (configurable via \restHost\, \restPort\, and \restContextPath\) that supports server-side TLS with certificate hot-reload, allowing secure trace queries without service restarts. It implements the Zipkin V2 API endpoints (e.g., \/api/v2/trace/{traceId}\, \/api/v2/traces\) and extends them with SkyWalking-specific parameters like \coldStage\ to query data from the BanyanDB cold storage tier. The implementation includes a new \ZipkinQueryConfig\ for module settings, a \ZipkinQueryProvider\ for initialization, and an exception handler to return clear error messages for illegal arguments. This enables users to query traces using the standard Zipkin protocol while leveraging SkyWalking's storage backend features.

oap-server/server-query-plugin/zipkin-query-plugin · high confidence

The server now supports configuring continuous profiling policies via the new ContinuousProfilingMutationService and ContinuousProfilingQueryService. Users can define policies targeting services, instances, or processes with specific check items (such as CPU, thread count, system load, HTTP error rate, and response time) and associated thresholds. The mutation service enforces strict validation rules, rejecting policies with zero or invalid thresholds, duplicate target or monitor types, and ensuring count does not exceed the period, while the query service retrieves these policies and recent trigger summaries.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/continuous · high confidence

The alarm subsystem now supports alarm recovery notifications, allowing users to receive alerts when an issue resolves, and captures a snapshot of the metrics that triggered the alarm for better context during investigation. Additionally, alarm records now include entity layer information (e.g., GENERAL, K8S\_SERVICE) to improve filtering and identification in the UI.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/alarm · high confidence

The server core now includes a new \exporter\ module that defines the foundational interfaces for exporting telemetry data. This change introduces the \ExporterModule\ and a generic \ExporterService\ interface, along with specific services for metrics (\MetricValuesExportService\), traces (\TraceExportService\), and logs (\LogExportService\). It also adds data models like \ExportData\ and \ExportEvent\ (supporting increment and total modes) to structure the data passed to these export pipelines.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/exporter · high confidence

The server now includes a new \Event\ record type in the core analysis module, allowing event data (such as service, endpoint, and message details) to be persisted and queried independently. This change also introduces a \LongText\ wrapper class to support the storage of string fields exceeding standard length limits, ensuring that longer log data or parameters can be saved without truncation.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/record · high confidence

The JVM receiver functionality is now packaged as a standalone plugin (\skywalking-jvm-receiver-plugin\) that registers a \JVMModule\ and \JVMModuleProvider\. This provider loads the JVM-specific OAL analysis script (\oal/java-agent.oal\) and registers gRPC handlers (\JVMMetricReportServiceHandler\ and a compatibility wrapper) to receive JVM metrics via the v3 protocol. The handler applies naming control rules to service and instance names before dispatching metrics, ensuring consistent naming and supporting the new protocol version while maintaining backward compatibility through the compat handler.

oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin · high confidence

The OAP server now includes a new configuration module that supports dynamic configuration changes at runtime. This change introduces the \DynamicConfigurationService\ interface, allowing modules to register watchers for configuration items that can be updated without a server restart. The API supports both single and group configuration items, with implementations for polling-based (\FetchingConfigWatcherRegister\) and listening-based (\ListeningConfigWatcherRegister\) change detection. A default \NoneConfigurationProvider\ is provided as a fallback, and the module is registered via Java SPI.

oap-server/server-configuration/configuration-api/src/main · high confidence

The server core now includes dedicated Java services for managing eBPF profiling tasks. The new EBPFProfilingMutationService handles the creation of profiling tasks (including network profiling with specific duration and sampling configurations) and the extension of active network profiling sessions. The EBPFProfilingQueryService provides the ability to query existing profiling tasks, check if a service supports eBPF profiling by analyzing process labels and traffic, and retrieve task details. These services act as the backend logic layer for the eBPF profiling feature, interacting with storage DAOs and metadata query services.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/ebpf · high confidence

This change introduces the new \skywalking-ebpf-receiver-plugin\ module, which enables the SkyWalking OAP server to receive telemetry data directly from eBPF agents. The plugin registers a dedicated gRPC service (or shares the existing one) to handle three main data streams: eBPF Access Logs (including Kubernetes process addresses and ztunnel mTLS analysis), eBPF Process data (host and Kubernetes process metadata), and eBPF Profiling data (both on-CPU and off-CPU profiling tasks and reports). It also includes a continuous profiling policy handler with a configurable cache timeout, allowing users to monitor network traffic and application performance at the kernel level without traditional agents.

oap-server/server-receiver-plugin/skywalking-ebpf-receiver-plugin · high confidence

The server core now exposes new DAO interfaces to support eBPF profiling capabilities. These interfaces allow querying eBPF profiling tasks by service or target type, retrieving profiling schedules associated with a task, fetching profiling data records within a time range, and listing service labels. This provides the underlying storage access layer required for the new eBPF profiling features.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/profiling/ebpf · high confidence

The core module now includes a new TTL subsystem that supports fine-grained, per-data-type expiration policies (separating metrics from records like traces, logs, and alarms) and exposes a \StorageTTLStatusQuery\ service. This allows storage implementations (such as BanyanDB) to define custom TTL definitions including hot/warm/cold stages, while the \DataTTLKeeperTimer\ orchestrates the actual deletion of expired data based on these configurations.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/ttl · high confidence

The meter analysis module now supports histogram and percentile metrics. New classes including HistogramFunction, BucketedValues, and PercentileArgument enable the ingestion and aggregation of bucketed data, allowing users to visualize distribution graphs and calculate percentile values from meter sources such as Prometheus.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function · high confidence

The new library-server module provides the foundational server implementations for the OAP server, replacing previous Jetty-based components. It introduces an Armeria-based HTTP server that supports TLS with automatic certificate hot-reload and shared event loops, alongside a gRPC server backed by Netty that supports mTLS and virtual threads on JDK 25+. This change establishes the core networking infrastructure for telemetry ingestion and HTTP endpoints.

oap-server/server-library/library-server · high confidence

This change adds the \skywalking-meter-receiver-plugin\, a new module that enables the OAP server to receive meter metrics via gRPC. It registers a \MeterReceiverModule\ and \MeterReceiverProvider\ that wire up \MeterServiceHandler\ and \MeterServiceHandlerCompat\ to the shared gRPC handler registry, allowing agents to stream \MeterData\ and \MeterDataCollection\ payloads. The receiver processes incoming meters through the existing \IMeterProcessService\, exposes latency and error metrics via telemetry, and includes a test configuration demonstrating meter analysis rules.

oap-server/server-receiver-plugin/skywalking-meter-receiver-plugin · high confidence

The OAP server now includes a dedicated \receiver-zipkin\ module that enables the ingestion of Zipkin-format traces via both HTTP endpoints (supporting JSON V1/V2, Protobuf, and Thrift payloads at \/api/v1/spans\ and \/api/v2/spans\) and Apache Kafka topics. This module provides configurable HTTP server settings (including TLS), Kafka consumer parameters, sampling rates, and rate limiting, while exposing telemetry metrics for trace ingestion latency, dropped spans, and analysis errors.

oap-server/server-receiver-plugin/zipkin-receiver-plugin · high confidence

The server core now defines a dedicated \LogRecord\ model and its dispatcher to handle log ingestion. This change introduces \AbstractLogRecord\ and \LogRecord\ classes that map log data (service, trace, content, tags) to storage, utilizing new annotations like \@SQLDatabase.AdditionalEntity\ to support additional tag tables and \@BanyanDB.TimestampColumn\ for timestamp handling. The \LogRecordDispatcher\ bridges incoming \Log\ source events to the new record stream processor, establishing the foundation for the new log collecting and query implementation.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/log · high confidence

This change adds a new, opt-in sharing server module that provides separate gRPC and REST endpoints for receiver traffic, allowing users to isolate external agent requests from internal OAP traffic to improve security and resource management. When enabled via configuration (e.g., setting \restPort\ or \gRPCPort\), the module starts independent Armeria-based HTTP and gRPC servers with support for TLS (including hot-reload for certificates), token-based authentication, and configurable thread pools and header sizes. If the sharing server is not activated, the module delegates to the core server's existing handlers, maintaining backward compatibility.

oap-server/server-receiver-plugin/skywalking-sharing-server-plugin · high confidence

This change adds the core backend components for the new pprof profiling feature. It introduces the PprofMutationService and PprofQueryService to handle the creation, validation, and querying of profiling tasks, alongside storage record definitions (PprofTaskRecord, PprofProfilingDataRecord, PprofTaskLogRecord) and their corresponding DAO interfaces. These files provide the internal data models and persistence abstractions required to manage pprof task lifecycles and store profiling data.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/pprof, oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/profiling/pprof · high confidence

The server now distinguishes how processes are discovered by adding a new \ProcessDetectType\ enum with a \VIRTUAL\ option for network-profiled processes that are not directly profileable. Additionally, a new \ServiceLabelRecord\ metric and its dispatcher are introduced to aggregate and store service-level labels, enabling faster identification of similar processes. These changes enhance the process analysis model by providing clearer context on process origins and grouping.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/process · high confidence

The server now supports the async profiler feature by introducing core services and storage models for managing profiling tasks and persisting Java Flight Recorder (JFR) data. The new AsyncProfilerMutationService allows users to create profiling tasks with specific durations, event types, and execution arguments, while enforcing a constraint that only one task can run per service at a time. The AsyncProfilerQueryService provides the ability to query these tasks and retrieve merged JFR stack trace data. Additionally, new storage records (AsyncProfilerTaskRecord, AsyncProfilerTaskLogRecord, and JFRProfilingDataRecord) and a dispatcher are added to handle the persistence and indexing of task metadata and profiling results in the backend storage.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/asyncprofiler · high confidence

The server now includes a dedicated data model for storing tag autocomplete information, enabling faster tag suggestions in queries. This change adds the \Tag\ class to represent key-value pairs, the \TagType\ enum to categorize tags by source (TRACE, LOG, ZIPKIN, ALARM, OTLP), the \TagAutocompleteData\ class to persist autocomplete records with specific storage annotations, and the \TagAutocompleteDispatcher\ to route source data into this new storage stream.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/searchtag · high confidence

The telemetry-api module now provides the core abstractions for server-side observability, defining interfaces for Counter, Gauge, and Histogram metrics, along with a MetricsCreator to instantiate them and a MetricsCollector to retrieve them. It also introduces a HealthCheckMetrics implementation that exposes health status via a gauge (1 for healthy, 0 for unhealthy, -1 for unknown), and includes a no-op provider to allow the system to run without an active telemetry backend.

oap-server/server-telemetry/telemetry-api · high confidence

The \library-client\ module now provides a standardized \Client\ interface and a \HealthCheckable\ contract, implemented by \ElasticSearchClient\, \GRPCClient\, and \JDBCClient\. These clients support configurable connection and socket timeouts, SSL/TLS settings, and integrated health checking with a \DelegatedHealthChecker\. Additionally, new \InsertRequest\ and \UpdateRequest\ interfaces are introduced to standardize data persistence operations, and an \ElasticSearchScroller\ is added to handle large result sets with automatic scroll context cleanup.

oap-server/server-library/library-client · high confidence

The server-core module adds a new set of Java classes in the \org.apache.skywalking.oap.server.core.query.mqe\ package to structure Metric Query Engine (MQE) responses. These new types—\ExpressionResult\, \ExpressionResultType\, \MQEMetric\, \MQEValue\, \MQEValues\, and \Metadata\—define the schema for returning query outcomes, including support for various result types like single values, time-series data, and sorted lists, as well as associated metadata and labels.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/mqe · high confidence

The OAL runtime now includes a new V2 engine implementation that replaces the previous Groovy-based DSL runtime. This engine parses OAL scripts using ANTLR4, enriches metric definitions with metadata, and generates Java classes at runtime using Javassist and FreeMarker templates. The new architecture provides immutable data models, type-safe filter values, and improved source location tracking for better error messages and debugging capabilities.

oap-server/oal-rt/src/main · high confidence

This change adds the foundational server-core components for the OAP server, including the GRPCHandlerRegister and HTTPHandlerRegister interfaces and their implementations to manage service and interceptor registration. It also introduces an AuthenticationInterceptor for gRPC that enforces token-based authentication between agents and the OAP receiver, verifying the token against a configured expected value and denying access if it does not match.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/server · high confidence

The OAP server now includes a dedicated gRPC health check service handler (HealthCheckServiceHandler) that implements the standard gRPC health checking protocol. This component allows external systems, such as Consul, to verify the server's availability by sending health check requests, which the server responds to with a 'SERVING' status.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote/health · high confidence

A new abstract base class, StreamData, has been added to the remote data package to support L1 and L2 aggregation across OAP nodes. This class implements Serializable and Deserializable interfaces and defines a remoteHashCode method, providing a standardized contract for data objects involved in distributed aggregation processes.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote/data · high confidence

The admin server now includes a live debugger for MAL (Meter Analyzer Language) and LAL (Log Analyzer Language) rules, allowing operators to inspect rule execution in real time. This change introduces cluster-aware session management via gRPC fan-out, enabling debug sessions to be installed, collected, and stopped across all OAP nodes in a cluster. For MAL rules, the debugger captures the full pipeline including input, filters, stages, downsampling, and meter emission, with support for multi-family metric payloads. For LAL rules, it provides both block-level and statement-level granularity, capturing text parsing, extraction, and output records. The implementation includes dedicated holder registries for both MAL and LAL catalogs, ensuring proper binding of debug sessions to live rule instances even during hot-updates.

oap-server/server-admin/dsl-debugging · high confidence

The profile-exporter tool now includes a mock implementation of the OAP core module provider (MockCoreModuleProvider) to support standalone operation without a full OAP backend. This mock replaces real services with no-op or simplified versions, including GRPC and HTTP handler registrations, source receivers, remote client management, worker instance services, and component library catalog lookups, enabling the tool to function independently for profile snapshot export.

oap-server/server-tools/profile-exporter/tool-profile-snapshot-server-mock · high confidence

The Nacos cluster plugin now supports configuring internal communication endpoints via \internalComHost\ and \internalComPort\, allowing cluster nodes to use specific internal addresses for communication. Additionally, the plugin now supports Nacos authentication, enabling users to configure either username/password or accessKey/secretKey for secure connections, as well as a custom \contextPath\ for Nacos server routing.

oap-server/server-cluster-plugin/cluster-nacos-plugin/src/main · high confidence

The server now stores OpenTelemetry Protocol (OTLP) traces natively, preserving the original binary payload and attribute types instead of converting them to the legacy Zipkin format. This change introduces new core data models (OTLPSpanRecord, OTLPServiceTraffic, OTLPServiceSpanTraffic, OTLPServiceRelationTraffic) and their corresponding source/dispatcher classes to index and store these traces. These catalogs feed the TraceQL value lists for service names, span names, and remote services, enabling more precise debugging and query capabilities for OTLP data.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query · high confidence

The OTLP receiver plugin now supports native storage of OpenTelemetry traces, allowing spans to be stored directly in the \otlp\_span\ table rather than being converted to Zipkin format. This introduces a new \otlpTraceStorage\ configuration option (defaulting to \otlp\, with \zipkin\ as a legacy fallback) and adds head sampling and rate-limiting controls (\otlpTraceSampleRate\, \otlpTraceMaxSpansPerSecond\) for the native path. The receiver module has been refactored to use an SPI-based \Handler\ interface, enabling extensible support for traces, logs, and metrics via dedicated handlers (\OpenTelemetryTraceHandler\, \OpenTelemetryLogHandler\, \OpenTelemetryMetricHandler\) that register gRPC and HTTP endpoints. Configuration validation ensures that native mode uses properly scoped searchable tags, and the module system now correctly orders dependencies to guarantee storage initialization before rule loading.

oap-server/server-receiver-plugin/otel-receiver-plugin · high confidence

A new fetcher plugin has been added to ingest observability data from Cilium Service network traffic. This plugin connects to a Cilium peer service via gRPC to stream flow data, which is then processed to generate metrics for L3/L4 and L7 traffic, DNS resolutions, and Kafka interactions. It supports configurable SSL connections, allows excluding specific namespaces or labels via YAML rules, and maps Cilium endpoint metadata to SkyWalking service instances for visibility into service-to-service communication.

oap-server/server-fetcher-plugin/cilium-fetcher-plugin · high confidence

The server-core module introduces three new Data Access Object interfaces to support trace profiling queries: IProfileTaskLogQueryDAO for retrieving task logs, IProfileTaskQueryDAO for searching and fetching profile tasks by service, endpoint, and time range, and IProfileThreadSnapshotQueryDAO for querying thread snapshot records and their sequence ranges. These interfaces define the contract for accessing profiling data stored in the backend, enabling the retrieval of task metadata and detailed thread-level snapshot information required for cross-thread trace profiling.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/profiling/trace · high confidence

The server-testing module now includes a comprehensive set of utilities for testing DSL rule engines. This adds loaders for LAL, MAL, and Hierarchy rules from YAML configurations, along with companion data builders for LAL log data and MAL mock samples. It also introduces mock implementations for the module manager and provider, enabling isolated unit testing of server components without requiring a full runtime environment.

oap-server/server-testing · high confidence

This change introduces a new Dockerfile, entrypoint script, and log configuration for the SkyWalking OAP (Observability Analysis Platform) server. The image is based on Eclipse Temurin JDK 25 JRE and exposes ports 12800, 11800, and 1234. The entrypoint script handles classpath construction by including configuration files, OAP libraries, and any user-provided extensions from ext-libs and ext-config directories, then launches the OAP server. The default log level is set to INFO, with specific formatting for ERROR logs that includes the SkyWalking version.

docker/oap · high confidence

The \library-async-profiler-jfr-parser\ module now includes a new Java-based parser for JFR files generated by async-profiler. This library introduces classes like \JFRConverter\, \JFRParser\, and \JFRToFrameTree\ to read JFR events (such as execution samples, allocations, and locks) and convert them into structured \FrameTree\ objects. It also provides utilities for classifying stack frames (e.g., GC, JIT, Native) and merging frame trees, enabling the server to process and analyze async-profiler profiling data.

oap-server/server-library/library-async-profiler-jfr-parser · high confidence

Skywalking OAP server now supports loading configuration dynamically from Kubernetes ConfigMaps. This new module allows users to specify a namespace and label selector to watch for ConfigMap changes, enabling runtime configuration updates without restarting the server. The implementation uses the Fabric8 Kubernetes client to inform on ConfigMap data and supports both individual key retrieval and grouped configuration items.

oap-server/server-configuration/configuration-k8s-configmap/src/main · high confidence

The OAL (Observability Analysis Language) engine now uses a new set of Java annotations to define metrics functions and filter logic. This location introduces the \@MetricsFunction\ annotation to mark metric functions, \@Entrance\ to identify entry points, and parameter-level annotations (\@Arg\, \@Expression\, \@SourceFrom\, \@ConstOne\, \@DefaultValue\) to configure function inputs. Additionally, \@FilterMatcher\ and \@BooleanValueFilterMatcher\ are added to define how filter expressions are processed, enabling the engine to support new filtering capabilities like \!=\ and \like\.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/metrics/annotation · high confidence

The OAL runtime engine in the server-core module now includes a comprehensive set of new expression matchers to support richer filtering logic. BooleanMatch and BooleanNotEqualMatch enable precise boolean comparisons, while NumberMatch, GreaterMatch, GreaterEqualMatch, LessMatch, and LessEqualMatch provide robust numeric comparisons across int, long, float, and double types. String filtering is enhanced with StringMatch for equality, LikeMatch for pattern matching (including %wildcards%), and InMatch for checking membership in a list of values. Additionally, ContainMatch and NotContainMatch allow filtering based on whether list fields contain or exclude specific items, and NotEqualMatch handles general inequality checks. These additions expand the capabilities of the OAL query language for more complex metric analysis.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/metrics/expression · high confidence

The Log Analysis Language (LAL) v2 engine introduces two new Service Provider Interfaces (SPIs) to support typed log analysis. LALSourceTypeProvider allows receiver plugins to declare the specific Java or Protobuf input types and default output types for each Layer, enabling the compiler to generate optimized direct getter calls and validate output field assignments at compile time. LalInputDebugRenderer provides a mechanism for receiver plugins (such as Envoy ALS) to render operator-readable JSON for complex input types that generic Protobuf printers cannot handle meaningfully, improving debuggability for features like Istio metadata-exchange peer decoding.

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/spi · high confidence

The trace processing pipeline now exposes a Service Provider Interface (SPI) called SpanListener, allowing external modules to intercept spans at two distinct points: before Zipkin conversion (for OTLP sources) and after conversion (for all sources). This new core component enables listeners to veto span persistence entirely or inject additional tags into the trace data, providing a standardized hook for custom trace processing logic without modifying the core receiver code.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/trace · high confidence

A new \skywalking-telegraf-receiver-plugin\ module has been added to the SkyWalking OAP server, enabling the ingestion of metrics from Telegraf agents over HTTP. The plugin registers a POST handler at \/telegraf\ that accepts JSON payloads containing metric data, converts them into SkyWalking meter samples, and stores them using the existing MeterSystem. It supports configuration via a \telegraf-rules\ directory and includes a default set of rules for common system metrics (CPU, memory, disk, network) in \vm.yaml\. The implementation relies on the new MAL/LAL V2 engine for rule processing and includes unit tests to verify the data conversion and ingestion pipeline.

oap-server/server-receiver-plugin/skywalking-telegraf-receiver-plugin · high confidence

A new admin-only Inspect module has been added to the admin server, exposing private REST endpoints to browse the metric catalog and inspect entity data. The \GET /inspect/metrics\ endpoint lists all registered metrics (filtering out internal and deprecated entries), while \GET /inspect/entities\ enumerates the entities holding values for a specific metric in a time range, decoding them into a human-readable format and providing an MQE-ready payload for further querying. The module also includes an \EntityDecoder\ to handle various service scopes and a test suite to verify the decoding logic.

oap-server/server-admin/inspect · high confidence

A new admin-server module is introduced, providing a dedicated HTTP host (default port 17128) and an internal gRPC port (default 17129) for privileged admin operations like DSL debugging and runtime rule management. This internal gRPC channel is isolated from the public agent port to prevent blast radius exposure and now supports TLS with certificate hot-reload for both the HTTP and gRPC interfaces, ensuring secure peer-to-peer cluster communication.

oap-server/server-admin/admin-server · high confidence

The OAP server now supports a new browser data upload protocol by introducing a comprehensive set of source data models in the browser source package. This includes dedicated classes for application-level and page-level performance metrics (such as redirect, DNS, TTFB, and Core Web Vitals like CLS and LCP), traffic counts categorized by normal or error types, resource loading details, and web interaction timings. Additionally, the server can now ingest and store raw browser error logs with specific error categories (AJAX, resource, Vue, Promise, JS), enabling more granular visibility into frontend user experience and errors.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/browser/source · high confidence

A new \skywalking-browser-receiver-plugin\ module has been added to the OAP server, enabling the ingestion of browser-side telemetry. This plugin registers gRPC and HTTP (POST) handlers to receive browser performance data (including web vitals, resources, and interactions) and error logs. It implements server-side sampling for error logs, generates unique IDs for logs to ensure global uniqueness, and forwards the processed data to the core source receiver for persistence.

oap-server/server-receiver-plugin/skywalking-browser-receiver-plugin · high confidence

The OAP server now includes dedicated in-memory caches (AsyncProfilerTaskCache, PprofTaskCache) and a unified CacheUpdateTimer to manage async and pprof profiling task data. These components cache task lists per service with a 1-minute write expiration and a 10-minute rolling window for database queries, reducing storage load and improving the responsiveness of profiling task lookups for users.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/cache · high confidence

The OAP server introduces a new core cluster module that provides the foundational interfaces and logic for cluster management. This includes a \ClusterCoordinator\ with a watch mechanism to notify listeners of node changes, a \ClusterHealthStatus\ model, and an \OAPNodeChecker\ that validates cluster health by ensuring instances are reachable, excluding illegal addresses like localhost, and handling receiver-specific checks. These components define the contract for cluster registration, node querying, and health monitoring within the server core.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/cluster · high confidence

The server core now introduces several new configuration services in the \oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/config\ package. \ComponentLibraryCatalogService\ loads component definitions and server mappings from \component-libraries.yml\, enabling the server to resolve client component names to their corresponding server-side types. \HierarchyDefinitionService\ reads \hierarchy-definition.yml\ and compiles auto-matching rules (via a pluggable \HierarchyRuleProvider\) to build service and instance hierarchies. \NamingControl\ enforces length limits on service, instance, and endpoint names and applies endpoint grouping. \SearchableTracesTagsWatcher\ allows the set of searchable trace tags to be updated dynamically at runtime. \DownSamplingConfigService\ configures data down-sampling to hourly or daily granularities, and \ConfigService\ centralizes access to core module settings like gRPC ports and data TTLs.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/config · high confidence

The server now includes \AIAgentSessionDataRecord\ and \AIAgentSessionFlowRecord\ classes to store AI agent conversation data. These new record types define the storage schema for session data files and conversation flow rounds, including fields for service identification, session/conversation IDs, sequence numbers, timestamps, and conversation metadata such as title, talk counts, and LLM call statistics. This enables the backend to persist and query AI agent interaction history.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/aiagent · high confidence

A new Docker image has been added to generate mock data for testing purposes. The image is based on Eclipse Temurin 11 JRE, exposes ports 12800, 11800, and 1234, and runs the DataGeneratorStartUp class via a custom entrypoint script that configures the classpath and applies specific logging and configuration overrides.

docker/data-generator · high confidence

A new data-generator module has been added to the server-tools, providing a standalone OAP instance designed to generate mock telemetry data for testing purposes. This tool introduces a suite of configurable data generators—including random and fixed strings, integers, booleans, UUIDs, timestamps, and sequences—that can be composed into templates for logs and distributed traces (segments). Users can drive this generation via new REST API endpoints (e.g., /mock-data/logs/tasks and /mock-data/segments/tasks), allowing them to specify generation volume or target QPS, and manage or cancel these background tasks programmatically.

oap-server/server-tools/data-generator · high confidence

The server now introduces a dedicated \EndpointTraffic\ metrics model and a set of new source dispatchers (\EndpointMetaDispatcher\, \EndpointTrafficDispatcher\, \HubbleEndpointDispatcher\, \K8SEndpointTrafficDispatcher\) to process endpoint data. This change centralizes the ingestion of endpoint traffic metrics from various sources—including standard endpoints, Cilium/Hubble observability data, and Kubernetes endpoints—into a single \EndpointTraffic\ stream, enabling unified storage and analysis of endpoint performance data.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/endpoint · high confidence

The server-core query layer introduces several new enumeration types to support expanded observability capabilities. GenAI Observability is supported by new enums for evaluation record sorting (GenAIEvaluationRecordSortBy), evaluation value types (GenAIEvaluationValueType), and trace reference types (GenAITraceRefType). eBPF profiling support is enabled via the ProfilingSupportStatus enum. Query flexibility is improved with new enums for metrics types (MetricsType), language identification (Language), sort order (Order), and time granularity (Step). Additionally, the Scope enum is updated to deprecate the 'All' scope in favor of specific scope categories, and the Finder logic is refined to map scope IDs to these specific categories.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/enumeration · high confidence

This change introduces the \receiver-event\ plugin, enabling the SkyWalking OAP server to receive application events via both gRPC and HTTP (REST) endpoints. The plugin registers \EventGrpcServiceHandler\ for gRPC streaming and \EventRestServiceHandler\ for POST requests to \/v3/events\, both of which validate that the required \layer\ field is present in the event data before passing it to the event analyzer. This allows users to instrument and report custom application events alongside traces, logs, and metrics.

oap-server/server-receiver-plugin/skywalking-event-receiver-plugin · high confidence

The OAP server now includes a new \event-analyzer\ module that provides the infrastructure to analyze and persist collected event data. This change introduces the \EventAnalyzer\ entry point, a listener-based architecture (\EventAnalyzerListener\) for extensible event processing, and a default \EventRecordAnalyzerListener\ that parses incoming event payloads (including layer, service, and timing information) and forwards them to the record persistence layer. The module is registered via standard service provider interfaces and depends on the CoreModule.

oap-server/analyzer/event-analyzer · high confidence

A new protobuf definition for the gRPC metric exporter service has been added, establishing the contract for exporting metric values. This includes the \MetricExportService\ with \export\ and \subscription\ RPCs, and defines message structures for \ExportMetricValue\ (containing metric name, entity details, time bucket, event type, and repeated metric values with optional labels) and \MetricValue\ (supporting long values and key-value labels). This change introduces the foundational schema for labeled metrics and streaming export capabilities.

oap-server/exporter/src/main/proto · high confidence

A new health-checker module has been added to the OAP server, providing an HTTP endpoint at /healthcheck that returns HTTP 200 OK when the server is healthy and HTTP 503 Service Unavailable when issues are detected. The module periodically collects health metrics from the Telemetry module, calculates a health score, and exposes this status through the HealthQueryService, allowing external systems to monitor the server's operational state.

oap-server/server-health-checker · high confidence

The OAP server library introduces a new modularization framework that manages the lifecycle of server components. This change adds the core infrastructure for module definitions, providers, and service registration, along with a bootstrap flow that handles dependency resolution, startup sequencing, and boot-completion notifications. It also includes configuration management via \ApplicationConfiguration\ and specific error handling for issues like duplicate providers, missing modules, and cyclic dependencies, ensuring a structured and robust initialization process for the collector.

oap-server/server-library/library-module · high confidence

The network protocol layer now supports new command types for profiling and configuration management. This includes commands for async-profiler, eBPF, pprof, and continuous profiling tasks, along with a configuration discovery command. These additions enable the server to send profiling tasks to agents and receive configuration updates, expanding the capabilities for network and application performance monitoring.

apm-protocol/apm-network/src/main/java · high confidence

This change introduces two new utilities in the tools directory. The profile exporter tool (profile\_exporter.sh, application.yml, log4j2.xml) allows users to export profiling data by connecting to the OAP server, accepting task and trace IDs as arguments, and packaging the results into a compressed archive. Additionally, a new script (tls\_key\_generate.sh) is provided to automate the generation of CA, server, and client keys and certificates, facilitating the setup of mutual TLS for secure agent-to-server communication.

tools · high confidence

A new standalone command-line tool is introduced in the \tool-profile-snapshot-bootstrap\ module to export and analyze thread profile snapshots. The tool bootstraps a minimal OAP environment to query profiled segments and their thread snapshots from storage, then dumps the data into local files (\basic.yml\ and \snapshot.data\). This enables users to perform offline analysis of profiling data without requiring a running OAP server, with the exported data being compatible with the \ProfileExportedAnalyze\ utility for stack tree visualization.

oap-server/server-tools/profile-exporter/tool-profile-snapshot-bootstrap · high confidence

This change introduces the \skywalking-profile-receiver-plugin\, a new module that enables the OAP server to receive and process profile tasks from language agents. The plugin registers a gRPC handler (\ProfileTaskServiceHandler\) to accept profile task commands, collect thread snapshots, and report Go profile data, while a compatibility layer (\ProfileTaskServiceHandlerCompat\) ensures interoperability with existing agent protocols. This allows users to initiate and manage profiling sessions directly through the OAP server infrastructure.

oap-server/server-receiver-plugin/skywalking-profile-receiver-plugin · high confidence

The server-core module introduces new query DAO interfaces to support emerging observability capabilities. IAIAgentConversationQueryDAO and IGenAIEvaluationRecordQueryDAO provide the backend storage access for querying AI agent conversation rounds/files and GenAI evaluation records, respectively. IAlarmQueryDAO adds a new queryAlarms method and resolveEntityFilters logic, enabling the 11.0.0 GraphQL queryAlarms endpoint to filter alarms by complex entity and relation scopes. IHierarchyQueryDAO exposes service and instance hierarchy relations for topology queries.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/query · high confidence

The server-core module introduces a suite of new input classes to support expanded query and configuration capabilities. Alarm queries now use AlarmQueryCondition with precise entity and tag filtering. Continuous and async profiling features are supported by new request models for task creation, analysis, and policy definitions. Browser error logs, GenAI evaluation records, and log queries by name are now handled by dedicated condition classes. Additionally, eBPF network profiling and sampling rules are defined via new input structures, and a generic attribute condition model supports not-equal filtering.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/input · high confidence

The server-core query types now include data models for async profiling (AsyncProfilerTask, AsyncProfilerStackTree, AsyncProfilerEventType), continuous profiling policies and monitoring instances, and alarm messages with snapshots. These additions enable the OAP server to query and return detailed profiling task states, stack traces, and alarm context data to clients.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/query/type · high confidence

The server now supports configurable strategies for selecting remote clients when sending stream data. A new \RemoteClientSelector\ interface and \Selector\ enum introduce three distinct selection behaviors: \HashCode\ (distributes load based on data hash), \Rolling\ (round-robin distribution), and \ForeverFirst\ (always selects the first available client). This allows users to control how telemetry data is distributed across multiple remote endpoints.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote/selector · high confidence

The server now persists sampled traces for slow requests, HTTP 4xx errors, and HTTP 5xx errors as distinct data models. These new record types (SampledSlowTraceRecord, SampledStatus4xxTraceRecord, and SampledStatus5xxTraceRecord) enable the system to store and query latency and error-specific trace data separately, supporting more granular network profiling and analysis.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/trace · high confidence

The server now introduces a dedicated \SegmentRecord\ model and \SegmentDispatcher\ to handle trace segment data. This change adds a new storage entity that captures segment-level metadata (such as service, endpoint, and instance IDs) and binary span data, routing it through the \RecordStreamProcessor\. The model is configured with specific storage annotations for BanyanDB (including trace ID/span ID columns and index rules) and ElasticSearch (routing and doc values), and it supports an additional tag table for storing segment tags separately.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/segment · high confidence

The core module now includes a new ServerStatusService that exposes server lifecycle states (booting status with uptime and cluster rebalance time) via a watcher mechanism, allowing modules to react to startup and cluster changes. Additionally, it introduces a ConfigDumpExtension SPI that enables modules (such as BanyanDB) to contribute their effective runtime configurations to the /debugging/config/dump API, ensuring secondary configuration files are included in the debug output alongside the main application configuration.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/status · high confidence

The server core now includes dedicated source classes to ingest and model new observability signals. Cilium network traffic is captured via CiliumMetrics and its service/endpoint/relation variants, exposing verdicts, protocol types, and layer details. Cache and database performance are tracked through CacheAccess, CacheSlowAccess, DatabaseAccess, and DatabaseSlowStatement sources, recording latency, operation status, and slow queries. eBPF-based continuous profiling is supported by EBPFProcessProfilingSchedule and EBPFProfilingData sources, which handle task scheduling and raw profiling data uploads. These additions expand the OAP server's ability to process and store metrics from these specific infrastructure and application layers.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source · high confidence

A new \skywalking-log-receiver-plugin\ module has been added to the server, providing dedicated handlers for receiving log data via both gRPC (\LogReportServiceGrpcHandler\) and HTTP POST (\/v3/logs\ via \LogReportServiceHTTPHandler\). This plugin registers itself with the shared server infrastructure and delegates log analysis to the V2 \LogAnalyzerModule\, enabling users to ingest logs through standard OTLP-compatible protocols without relying on the previous monolithic receiver setup.

oap-server/server-receiver-plugin/skywalking-log-receiver-plugin · high confidence

The \oap-server/server-admin/status\ module introduces a new set of HTTP handlers that expose cluster topology, alarm rule configurations, and per-query debugging capabilities on the admin-server REST port. Users can now query the list of cluster nodes via \/status/cluster/nodes\, retrieve alarm rules and their running contexts via \/status/alarm/\*\, and inspect TTL configurations via \/status/config/ttl\. Additionally, the \DebuggingHTTPHandler\ provides diagnostic endpoints for querying traces, logs, metrics expressions (MQE), and service/endpoint/instance/process topologies, returning detailed debugging traces alongside the results to aid in troubleshooting. The \/status/config/ttl\ endpoint is also exposed on the public REST host for backward compatibility with ecosystem tools.

oap-server/server-admin/status · high confidence

The server core now exposes dedicated DAO interfaces to query Async Profiler artifacts: \IAsyncProfilerTaskLogQueryDAO\ retrieves task logs by task ID, \IAsyncProfilerTaskQueryDAO\ lists tasks within a time range and fetches individual tasks by ID, and \IJFRDataQueryDAO\ retrieves JFR profiling data records filtered by task ID, instance IDs, and event type. These interfaces provide the storage-layer contracts required to support the Async Profiler feature.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/profiling/asyncprofiler · high confidence

The metering engine now includes three new aggregation functions—\sum\, \sumLabeled\, and \sumHistogramPercentile\—allowing users to aggregate metrics by summing raw values rather than relying solely on averages or histograms. \sum\ provides a basic counter-style aggregation, \sumLabeled\ supports labeled metrics for more granular breakdowns, and \sumHistogramPercentile\ enables calculating percentiles based on the sum of raw values over time intervals (minute, hour, or day). These functions are implemented in the core analysis module and include full serialization, storage, and downsampling support.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/sum · high confidence

Added a new benchmark case that automates the collection and analysis of thread dumps from SkyWalking OAP pods. The setup script provisions a Kind cluster with an Istio-enabled OAP environment backed by BanyanDB, while the benchmark runner periodically captures thread dumps (using jstack, jcmd, or SIGQUIT fallbacks) and generates a report analyzing thread pool usage, excluding JVM internal threads to highlight application-level contention.

benchmarks · high confidence

This change introduces a new receiver plugin that enables agents to register service instances and report properties via the v8 management protocol. The plugin registers gRPC and HTTP handlers (using Armeria) to process \reportInstanceProperties\ and \keepAlive\ requests, mapping incoming data to internal \ServiceInstanceUpdate\ and \ServiceMeta\ sources for downstream processing.

oap-server/server-receiver-plugin/skywalking-management-receiver-plugin · high confidence

The trace receiver module has been restructured into a new plugin (receiver-trace) that registers handlers for the v8 gRPC and REST protocols. This update introduces a new SpanAttachedEventReportServiceHandler to capture span-attached events alongside the existing TraceSegmentReportServiceHandler for standard trace segments. A compatibility handler is also provided to support legacy clients, while the REST handler exposes POST endpoints at /v3/segment and /v3/segments for HTTP-based trace ingestion.

oap-server/server-receiver-plugin/skywalking-trace-receiver-plugin · high confidence

The server now persists runtime-updated MAL (Metric Analysis Language) and LAL (Log Analysis Language) rule files into the \runtimerule\ storage index. This change introduces a new \RuntimeRule\ entity that stores the rule's catalog, name, raw content, and active/inactive status, allowing the system to track and reconcile these dynamic rules across nodes using content-hash comparison rather than version counters. Users can now have their hot-updated rules survive server restarts and be consistently managed alongside static configurations.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/management/runtimerule · high confidence

Operators can now define custom runtime layers in MAL and LAL rule files. The runtime-rule module introduces a new classification pipeline (DeltaClassifier) that detects structural changes, including new or modified layer definitions, and applies them atomically via the RuntimeLayerRegistry before compiling the rules. This ensures that rules referencing these dynamic layers are registered correctly and that alarm windows are reset only for the affected metrics, avoiding unnecessary data loss during hot-updates.

oap-server/server-admin/runtime-rule · high confidence

The server now includes a new analysis pipeline for eBPF profiling data, enabling the generation of flame graphs from collected stack traces. This change introduces the \EBPFProfilingAnalyzer\ and supporting classes (\EBPFProfilingStack\, \EBPFProfilingStackNode\, \EBPFProfilingAnalyzeCollector\) within the \oap-server/server-core\ module. The analyzer queries raw profiling records, deserializes them into stack structures, and aggregates them into tree structures suitable for visualization. It supports both ON-CPU and OFF-CPU profiling types, handling duration and switch count metrics for OFF-CPU data, and processes queries in parallel batches to manage large time ranges efficiently.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/ebpf/analyze · high confidence

The server now includes core infrastructure to manage UI templates, introducing a new \UITemplate\ data model and \UITemplateManagementService\. This enables the storage, retrieval, creation, modification, and disabling of dashboard configurations via a dedicated DAO, laying the groundwork for dynamic UI customization and template initialization features.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/management/ui · high confidence

The server now automatically builds and maintains service and instance hierarchy relations (e.g., mapping MESH services to K8S services) using configurable matching rules. This is achieved through a new \HierarchyService\ that runs a background task every 20 seconds to match known services against compiled rules, alongside explicit relation creation from agent telemetry. The implementation introduces new data models (\ServiceHierarchyRelation\, \InstanceHierarchyRelation\) and their corresponding traffic metrics (\ServiceHierarchyRelationTraffic\, \InstanceHierarchyRelationTraffic\) to persist and query these hierarchical relationships.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/hierarchy · high confidence

The server now registers its core components via Java Service Provider Interface (SPI) files. Specifically, the \ModuleDefine\ file declares the storage, cluster, core, query, alarm, and exporter modules, while the \ModuleProvider\ file registers the core module provider, enabling the framework to discover and initialize these parts of the system.

oap-server/server-core/src/main/resources · high confidence

Users can now export distributed traces and log records to Apache Kafka. This change introduces the Kafka exporter implementation, including \KafkaLogExporter\ for persisting logs (supporting JSON, YAML, and Text content types) and \KafkaTraceExporter\ for sending trace segment data. The trace exporter includes a configuration option to export only traces with error status segments. Both exporters utilize a batch queue for efficient processing and expose success/error metrics for monitoring.

oap-server/exporter/src/main/java/org/apache/skywalking/oap/server/exporter/provider/kafka · high confidence

The server now records span-attached events for both SkyWalking and Zipkin traces. New data models (SWSpanAttachedEventRecord and SpanAttachedEventRecord) store event details such as start/end times, event type, and binary payload, linking them to their respective trace contexts. This enables users to view and analyze custom events attached to spans within their trace visualizations.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/manual/spanattach · high confidence

The OAP server now processes browser application page traffic data. A new dispatcher component routes incoming page traffic metrics to the standard endpoint traffic processing pipeline, enabling the aggregation and analysis of browser-side page performance data alongside other endpoint metrics.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/browser/manual/endpoint · high confidence

The server now automatically groups and normalizes endpoint names by parsing OpenAPI specification files (YAML) or dynamic configuration entries. This feature introduces a new configuration watcher that reads OpenAPI definitions to extract service names and path patterns, applying configurable formatting rules (defaulting to ${METHOD}:${PATH}) to create consistent endpoint names. It supports both static file-based definitions and dynamic updates, allowing users to reduce metric cardinality by grouping similar API endpoints defined in their OpenAPI specs.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/config/group/openapi · high confidence

The Zipkin module introduces new data models to support BanyanDB's IndexMode, enabling more efficient storage and querying of trace data. This includes \ZipkinServiceTraffic\, \ZipkinServiceSpanTraffic\, and \ZipkinServiceRelationTraffic\ metrics classes, which track service-level traffic, span counts, and service-to-service relations respectively. Additionally, \ZipkinSpanRecord\ is added to store detailed span information, utilizing BanyanDB-specific annotations like \@BanyanDB.IndexMode\ and \@BanyanDB.Trace\ for optimized indexing and trace grouping. Corresponding dispatchers are implemented to route incoming Zipkin source data to these new models, ensuring that Zipkin traces are processed and stored using the new IndexMode structure.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/zipkin · high confidence

The Zookeeper cluster plugin now supports configuring a namespace to isolate cluster data and enables Zookeeper ACLs for authentication, allowing users to secure their cluster coordination with digest-based credentials.

oap-server/server-cluster-plugin/cluster-zookeeper-plugin/src/main · high confidence

The iOS analyzer module now ingests telemetry from iOS and iPadOS applications instrumented with the OpenTelemetry Swift SDK. It introduces two new span listeners: IOSHTTPSpanListener extracts HTTP traffic metrics (latency, status codes, CPM) from URLSession spans and emits them as Service, ServiceInstance, and Endpoint sources under the IOS layer, while IOSMetricKitSpanListener converts daily MetricKit aggregates (app launch time, hangs, CPU/GPU/memory usage, network transfers, and abnormal exits) into metrics via the Metering Analysis Language (MAL) pipeline without persisting them as traces. The listeners are registered via the standard Java Service Provider Interface (SPI) mechanism.

oap-server/analyzer/ios-analyzer · high confidence

The Elasticsearch storage plugin has been reorganized into a new modular structure. A new \StorageModuleElasticsearchConfig\ class centralizes all configuration options, including connection settings (timeout, protocol), index management (shards, replicas, day steps, specific index settings), and bulk processing parameters (bulk actions, flush interval, batch size). New base classes in the \base\ package provide foundational functionality: \BatchProcessEsDAO\ handles asynchronous bulk indexing with configurable flush policies, \AnalyzerSetting\ manages custom Elasticsearch analyzers for OAP and log queries, \ColumnTypeEsMapping\ defines the mapping between Java types and Elasticsearch field types, \ElasticSearchConverter\ handles data serialization/deserialization with physical column name resolution, \EsDAO\ provides debuggable search and scroll operations, and \HistoryDeleteEsDAO\ manages TTL-based index deletion. The \StorageModuleElasticsearchProvider\ wires these components together, initializing the Elasticsearch client and registering all DAO implementations.

oap-server/server-storage-plugin/storage-elasticsearch-plugin · high confidence

The BanyanDB storage plugin has been replaced with a native Java implementation, removing the previous Java client dependency. This change introduces a new data access architecture featuring dedicated DAOs for aggregation queries and batched writes, a new configuration loader that reads from separate YAML files, and a comprehensive index installer that manages schema creation and drift detection. For users, this means the storage backend now handles metrics, traces, and logs through a more direct and configurable native path, with configuration options now exposed via the debugging config dump.

oap-server/server-storage-plugin/storage-banyandb-plugin · high confidence

Integration tests now use a centralized utility (ITVersions) to read version information from the environment file, ensuring consistent version management across tests. Additionally, a new BanyanDBTestContainer class provides a single source of truth for the BanyanDB container image and port configuration, including optimized settings for testing such as reduced cache wait durations and flush timeouts to improve test reliability and speed.

oap-server/server-library/library-integration-test · high confidence

The core analysis module has been refactored to improve extensibility and maintainability. A new Layer registry system has been introduced, allowing custom layers to be registered via YAML configuration or Java SPI without modifying OAP source code, with support for runtime dynamic layer definitions. The IDManager has been updated to support service hierarchy relations and improved entity identification. A new DispatcherManager centralizes source event routing, enabling better debugging and metric analysis. Additionally, new annotations (@Disable, @MetricsExtension) and configuration dictionaries (ApdexThresholdConfig) have been added to support more flexible metric configuration and entity disabling.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis · high confidence

The server now groups endpoint names using a new \QuickUriGroupingRule\ engine that matches URIs against a tree of string and variable tokens, replacing the previous regex-based \EndpointGroupingRule\ (now deprecated). This change introduces support for grouping by OpenAPI definitions and AI/ML-powered HTTP URI recognition, while also ensuring that unformatted endpoints with high cardinality are grouped into \\_abandoned\ to reduce storage load. Configuration is managed via a new \EndpointNameGroupingRuleWatcher\ that applies rules dynamically from the \endpoint-name-grouping\ configuration source.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/config/group · high confidence

The GraphQL query plugin now executes queries asynchronously using a shared ForkJoinPool, which improves server responsiveness by preventing long-running queries from blocking the main thread. Additionally, a configurable maximum query complexity limit (defaulting to 1000) is enforced to protect the server from malicious or overly complex queries that could degrade performance.

oap-server/server-query-plugin/query-graphql-plugin · high confidence

The hierarchy matching engine has replaced the previous Groovy-based DSL execution with a new v2 compiler that parses rule expressions using ANTLR4 and generates optimized Java bytecode via Javassist at startup. This change significantly improves the performance and stability of service hierarchy matching by compiling rules into native \BiFunction\ classes rather than interpreting them at runtime. The new compiler supports the same rule syntax (including property access, comparisons, and logical operators) but provides better error reporting and debugging capabilities through precise source file and line number attribution in generated stack traces. Existing hierarchy definitions in \hierarchy-definition.yml\ will be processed by this new engine, ensuring consistent and faster service matching behavior.

oap-server/analyzer/hierarchy · high confidence

The alarm system has been rewritten to use the MQE (Metric Query Expression) language for defining alarm rules, replacing the previous expression engine. This change introduces a new \AlarmKernel\ that manages rule evaluation windows and supports dynamic configuration updates via the configuration center. The core now handles firing and recovery notifications through a unified \NotifyHandler\ that dispatches to multiple webhook channels including Webhook, gRPC, Slack, DingTalk, Feishu, WeLink, Discord, and PagerDuty. The implementation includes new classes for rule parsing (\AlarmRule\, \AlarmRulesWatcher\), state management (\AlarmCore\, \RunningRule\), and status monitoring (\AlarmStatusWatcher\), providing a more robust and extensible alarm infrastructure.

oap-server/server-alarm-plugin/src/main · high confidence

The OAP server now uses a new bootstrap entry point (OAPServerBootstrap) that initializes the module manager, loads the primary application.yml configuration, and applies system property overrides. This change introduces a dedicated ApplicationConfigLoader to handle YAML parsing, provider selection via selectors, and environment variable substitution, while also adding default configuration files for AI evaluation (ai-evaluation.yml) and alarm rules (alarm-settings.yml).

oap-server/server-starter · high confidence

The OAP server core now uses a new internal gRPC protocol for inter-node data streaming, replacing the previous mechanism. This change introduces new interfaces (Serializable, Deserializable) and services (RemoteSenderService, RemoteServiceHandler) to handle serialization, routing (via HashCode, Rolling, or ForeverFirst selectors), and reception of streaming data. Users benefit from improved reliability and observability, including specific metrics for remote in-count, errors, target-not-found events, and latency, as well as better handling of stream cancellations without logging them as errors.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote · high confidence

The storage layer now uses new \Convert2Entity\ and \Convert2Storage\ interfaces to handle data transformation between OAP entities and database structures, replacing previous ad-hoc conversion logic. A \HashMapConverter\ implementation is provided as the default converter, which encodes binary fields as BASE64 strings when storing data and decodes them when reading. Additionally, a \StorageBuilder\ interface is introduced to standardize how storage implementations build entities from raw data and vice versa, and a \StorageDataComplexObject\ interface is added to support serialization of complex objects as strings.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/type · high confidence

The OAL (Observability Analysis Language) engine has been upgraded to version 2, introducing a new runtime architecture in the server-core module. This change replaces the previous engine implementation with OALEngineV2, loaded via reflection to maintain module separation. The new engine supports multiple OAL configurations through the OALDefine abstraction, allowing receivers to register specific script files and source packages. It also introduces a dedicated disable mechanism via DisableOALDefine and improves the compilation error handling with a specific OALCompileException, ensuring that OAL scripts are processed and validated by the new V2 runtime.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/oal · high confidence

The JDBC storage plugin has been restructured to improve performance and maintainability. A new batch SQL execution engine (BatchSQLExecutor) now handles bulk inserts and updates, configurable via the new JDBCStorageConfig settings for batch size and async pool size. Table management is centralized in TableHelper and JDBCTableInstaller, which handle day-based table rolling, index creation, and existence checks. The plugin also introduces TableMetaInfo to track local models and JDBCEntityConverters for result set mapping, providing a more robust foundation for all JDBC-backed data persistence.

oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin · high confidence

The Log Analysis Language grammar has been replaced with a new ANTLR4-based definition (LALLexer.g4 and LALParser.g4), introducing support for local variables via the 'def' keyword, explicit type casting using 'as', and unified arithmetic operators (+, -, \*, /) with Java-like type promotion. This change updates the core syntax rules for parsing log analysis scripts, enabling more complex data manipulation and type handling within the analyzer.

oap-server/analyzer/log-analyzer/src/main/antlr4 · high confidence

The log analyzer V2 engine is now registered with the application's module system via new META-INF/services files. This wiring connects the \LogAnalyzerModule\ and \LogAnalyzerModuleProvider\ implementations, enabling the new ANTLR4-based parsing engine to be loaded and used for log analysis instead of the previous Groovy DSL runtime.

oap-server/analyzer/log-analyzer/src/main/resources · high confidence

The log analysis engine has been restructured to route incoming logs through a layer-based listener system. The new \LogAnalyzer\ entry point validates logs and dispatches them to specific \LogAnalysisListener\ instances (such as \LogFilterListener\) based on the telemetry layer (e.g., GENERAL, MESH). This allows for more precise rule matching, including auto-layer detection and source-type filtering. Processed results are then handled by dedicated sink listeners like \RecordSinkListener\ for persistence or \TrafficSinkListener\ for generating service and endpoint traffic metrics.

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/provider/log · high confidence

The log-analyzer module now uses a v2 engine that replaces the previous Groovy-based runtime with an ANTLR4 + Javassist compilation pipeline. This change enables runtime hot-updates for both LAL (Log Analysis Language) and MAL (Metric Analysis Language) rules, allowing operators to modify or replace rules without restarting the OAP server. LAL rules now support a dynamic 'auto' layer mode, where the script determines the service layer at runtime, and can register custom layers inline. The module provider manages a volatile registry of metric converters and LAL filter factories, ensuring that static boot-time rules and dynamic runtime updates share the same key scheme for seamless replacement.

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/provider · high confidence

The MQE (Metric Query Expression) grammar now supports a broader set of query capabilities, including trend functions (\increase\, \rate\), boolean logic (\&&\, \\|\|\), and advanced aggregation features like \top\_n\_of\, \view\_as\_seq\, \is\_present\, \sort\_values\, and \sort\_label\_values\. Users can also utilize comparison operators, baseline queries, and additional attribute filters (\attr0\–\attr5\) within their metric queries.

oap-server/mqe-grammar · high confidence

The Meter Analysis Language (MAL) engine has been replaced with a new v2 implementation that uses ANTLR4 for parsing and Javassist for bytecode generation, replacing the previous Groovy-based runtime. This change introduces new grammar definitions (MALLexer.g4, MALParser.g4) and a dedicated compilation pipeline (MALClassGenerator, MALBytecodeHelper) that compiles MAL expressions into optimized Java classes at runtime. The new engine supports hot-updates for MAL and LAL rules via a per-file classloader strategy, allowing rules to be added, replaced, or removed without restarting the OAP server. It also improves debugging by providing accurate source attribution (file and line numbers) in generated bytecode and stack traces, and introduces a MalConverterRegistry to manage rule converters dynamically.

oap-server/analyzer/meter-analyzer/src/main · high confidence

The Meter system in the OAP server core has been updated to support adding up to six additional attributes (attr0 through attr5) for service-level metrics. This change is implemented in the Meter and MeterEntity classes, which now include fields for these attributes and methods to decorate metrics with entity attributes. This enhancement allows for more detailed and flexible metric data collection and analysis at the service level.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter · high confidence

The Kubernetes support library has switched from the kubernetes-client/java library to the Fabric8 Kubernetes client. This change introduces a shared singleton client to reduce thread overhead and implements new caching wrappers for Kubernetes resources (Pods, Services, Endpoints) and Istio ServiceEntries. These components use Guava loading caches with short expiration times (3–5 minutes) to fetch and store resource lists, enabling more efficient lookups for cluster coordination and service discovery without repeatedly hitting the API server.

oap-server/server-library/library-kubernetes-support · high confidence

The OAL grammar has been replaced with a new runtime engine definition (OALLexer.g4 and OALParser.g4). This update introduces support for new data sources including Browser metrics, eBPF events, GenAI provider/model access, Cilium service network traffic, and K8s entities. It also adds new filter expressions such as IN, NOT\_EQUAL, and LIKE, along with type cast functions like (str-\>long) and (str-\>int), enabling more complex metric aggregation and filtering rules in OAL scripts.

oap-server/oal-grammar · high confidence

The server introduces a new buffering architecture for metrics and TopN data to improve concurrency and aggregation. A new \ReadWriteSafeCache\ provides thread-safe, isolated read/write access by swapping between two underlying buffers, allowing concurrent reads while writes are in progress. This cache hosts two specific buffer implementations: \MergableBufferedData\, which combines metrics with identical IDs using their \combine\ method, and \LimitedSizeBufferedData\, which maintains a fixed-size TopN list grouped by entity ID and time bucket, discarding lower-value entries when the limit is reached. This change replaces previous aggregation and caching logic with a more structured, thread-aware approach.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/data · high confidence

The server introduces two new Protocol Buffers definitions to handle internal data exchange. RemoteService.proto defines a gRPC service for cluster-wide remote calls, including a syncStatus RPC that allows querying the running status of the alarm subsystem across the cluster. SpanWrapper.proto defines a message structure for storing trace spans, introducing a Source enum that explicitly supports OTLP (OpenTelemetry Protocol) alongside existing SkyWalking and Zipkin sources, enabling native storage of OTLP traces.

oap-server/server-core/src/main/proto · high confidence

The OAP backend startup scripts (startup.sh, startup.bat, and oapService variants) have been updated for version 11.0.0. The default maximum heap size for the OAP process has been increased to 4096M (from 512M on Windows and lower limits previously) to help avoid OutOfMemory errors. Additionally, the bundled web UI has been removed from the distribution; the startup scripts now launch only the OAP backend process, with comments directing users to the separate skywalking-horizon-ui project for the frontend.

dist-material/bin · high confidence

The OAP server now exposes its version details (build version and commit ID) through a new \Version\ enum and a Log4j pattern converter (\%swversion\). This allows the version to be displayed in startup messages and error logs, and supports a GraphQL query to retrieve the OAP version programmatically, replacing the previous build-time version format.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/version · high confidence

The Elasticsearch storage client has been completely rewritten to use the Armeria HTTP client instead of the previous Java High-Level REST Client. This new implementation introduces a version-aware architecture that automatically selects the correct request factory and codec for Elasticsearch 6.x, 7.x (including 7.8+), 8.x, 9.x, and OpenSearch, ensuring compatibility with modern APIs like composable index templates and typeless documents. The update also adds support for mutual TLS (client certificate authentication) via configurable trust and key stores, exposes configurable response and socket timeouts, and introduces a new bulk processor with byte-size limits to optimize data persistence performance.

oap-server/server-library/library-elasticsearch-client · high confidence

The internal cluster communication layer has been refactored to use a new \RemoteClient\ interface and \RemoteClientManager\. This introduces a dedicated \Address\ model for server endpoints, a \SelfRemoteClient\ for local data aggregation (fixing self-observing metrics), and a \GRPCRemoteClient\ that utilizes a \BatchQueue\ for buffered, batched message sending. The manager now automatically refreshes connections based on cluster node queries and supports SSL context configuration, improving reliability and observability of inter-server data flow.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote/client · high confidence

The core metrics analysis classes in the \oap-server/server-core\ module have been refactored to improve structure and performance. This change introduces new abstract metric classes including \ApdexMetrics\, \CPMMetrics\, \CountMetrics\, \HistogramMetrics\, \LabelAvgMetrics\, and \LabelCountMetrics\, alongside supporting data structures like \DataLabel\ and \DataTable\. The refactoring standardizes how metrics are combined, calculated, and stored, with specific attention to storage annotations for Elasticsearch and BanyanDB. Additionally, value holder interfaces (\IntValueHolder\, \LongValueHolder\, \DoubleValueHolder\, \LabeledValueHolder\) have been introduced to provide a consistent way to access metric values across different metric types.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/metrics · high confidence

The average-based meter functions (AvgFunction, AvgHistogramFunction, AvgHistogramPercentileFunction, and AvgLabeledFunction) have been refactored to replace primitive accumulation fields with \DataTable\ objects for storing summation, count, and value data. This change, combined with the adoption of the new \StorageID\ object for entity identification, ensures that metric data is correctly serialized and deserialized across storage backends like Elasticsearch and BanyanDB. For users, this resolves issues where meter metrics were reported incorrectly (such as the smallest finite bucket boundary being returned) and ensures that labeled and histogram percentile metrics are persisted and retrieved accurately.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/avg · high confidence

The metrics processing pipeline in the OAP server has been refactored to replace the previous DataCarrier mechanism with a new BatchQueue-based architecture. This change introduces adaptive partitioning to the L1 aggregation and L2 persistence queues, ensuring that metrics of the same type are processed by the same thread to improve cache locality and reduce contention. The system now distinguishes between OAL (native SkyWalking) and MAL (meter/Prometheus) metrics, applying different partition weights to optimize resource usage for high-throughput OAL data versus lower-throughput MAL data. Additionally, new worker classes such as MetricsAggregateWorker, MetricsPersistentMinWorker, and ManagementStreamProcessor have been introduced to handle specific stages of the pipeline, including in-memory merging, minute-level persistence, and management data handling, while also exposing queue usage metrics for better observability.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/worker · high confidence

The storage annotation package has been reorganized into dedicated holders for each backend: \BanyanDB\ (with \SeriesID\, \ShardingKey\, \IndexRule\, and \TimestampColumn\), \ElasticSearch\ (with \MatchQuery\, \Keyword\, and \EnableDocValues\), and \SQLDatabase\ (with \CompositeIndex\ and \AdditionalEntity\). The generic \Column\ annotation was updated to include \indexOnly\ and \LABELED\_VALUE\ support, while the \Storage\ class now explicitly exposes model name, time-relative ID, and downsampling settings. Additionally, a new \ForeignMetricMeta\ and \InspectQueryContext\ mechanism allows the admin inspect API to read metric values for metrics not locally defined by OAP, filling metadata gaps on a per-request basis.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/annotation · high confidence

The storage model layer has been restructured to centralize metadata and installation logic. New extension classes (BanyanDBExtension, ElasticSearchExtension, SQLDatabaseExtension) now hold storage-specific column and model settings, replacing scattered annotation-based configuration. The core Model and ModelColumn classes have been updated to include these extensions, along with new capabilities like BanyanDB trace model support (traceId/spanId columns) and boot-time reshape flags. A new ModelInstaller abstract class and StorageManipulationOpt policy system now govern schema installation, introducing strict modes for schema verification, peer-node reconciliation, and deferred DDL to the init node, ensuring consistent and safe schema evolution across different storage backends.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage/model · high confidence

The OAP server's core storage module has been refactored to introduce a new set of specialized DAO interfaces (such as IBatchDAO, IMetricsDAO, and IRecordDAO) and a new StorageID object to replace the previous string-based ID system. This change introduces a structured batch persistence mechanism via the PersistenceTimer, which coordinates concurrent flush operations and ensures data integrity by waiting for storage acknowledgments before completing a round. Additionally, the module now exposes a StorageBuilderFactory to allow storage implementations to provide native data builders, and registers a comprehensive set of query and management services (including AI agent conversations, profiling, and metadata queries) within the StorageModule.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/storage · high confidence

The core worker module has been refactored to introduce a dedicated service layer for managing worker instances, enabling runtime rule hot-updates for MAL and LAL metrics. This change adds an abstract base worker class and a new service that handles registration, retrieval, and removal of workers. Crucially, the new service now supports removing worker registrations, which prevents duplicate-name errors and allows metrics to be re-registered during hot-update scenarios, fixing previous malfunctions in the alarm feature.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/worker · high confidence

The exporter module is now registered with the framework's service loader mechanism, allowing the system to automatically discover and initialize the ExporterProvider. This enables the core infrastructure to load the exporter components required for sending telemetry data.

oap-server/exporter/src/main/resources · high confidence

The BanyanDB client library in the server-library module has been replaced with a new native Java implementation. This change introduces a complete rewrite of the client-side API, including new classes for building queries (AbstractQuery, MeasureQuery), handling write operations (AbstractWrite, MeasureWrite), and managing logical criteria (AbstractCriteria, And, Or). The new client supports gRPC communication with BanyanDB, including features like tag projections, field projections, aggregations, and ordering. It also includes support for TLS, authentication, and connection management through the Options class and ChannelManager.

oap-server/server-library/library-banyandb-client · high confidence

Operators can now modify MAL and LAL rules at runtime without restarting the server. The server-core module introduces a new extension mechanism where disk-based rule definitions are merged with overrides from pluggable resolvers (such as the runtime-rule plugin) based on priority. This allows rules to be activated, deactivated, or updated dynamically via the REST API, with the system tracking original disk content to support delta-based updates and ensuring that purely runtime rules remain removable by operators.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/rule · high confidence

The DSL compilation pipeline has been refactored to share a single, deterministic naming scheme and source-attribute model across OAL, MAL, LAL, and Hierarchy. Generated class names now consistently follow the \{sanitizedRuleFile}\L{line}\{hint}\ pattern, and source coordinates (file and line) are reliably resolved from YAML, ensuring stack traces and debugging output point to the correct rule location. A new \Catalog\ enum replaces string literals for rule types, and a dedicated \DSLClassLoaderManager\ now handles the creation, retirement, and garbage-collection monitoring of per-file class loaders, preventing silent memory leaks by detecting when retired loaders are not collected.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/dsl · high confidence

The gRPC metrics exporter has been updated to unify metric value types and introduce support for labeled metrics. This change replaces the previous internal queue mechanism with a new BatchQueue implementation for the metrics pipeline and ensures that metrics carrying labels (LabeledValueHolder) are correctly serialized and exported alongside standard long and integer values, providing a consistent interface for downstream consumers.

oap-server/exporter/src/main/java/org/apache/skywalking/oap/server/exporter/provider/grpc · high confidence

The release distribution now includes a comprehensive LICENSE file, a LICENSE.tpl template for generating subcomponent license lists, a NOTICE file with third-party attributions, and a README.txt. Additionally, individual license text files for dependencies such as H2, ANTLR4, ASM, Bouncy Castle, and others are included in the licenses directory to ensure full compliance and transparency for users.

dist-material/release-docs · high confidence

The server now monitors heap and direct memory usage to detect overload conditions. When memory thresholds are exceeded, a new watermark mechanism triggers circuit breaking, causing the gRPC interceptor to reject incoming requests with a RESOURCE\_EXHAUSTED status. This protects the system from further strain during high-load scenarios, and includes metrics to track break and recovery events for self-observability.

oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/watermark · high confidence

Add ActiveMQ monitoring E2E tests; Add e2e-protocol submodule for Java test service; Added LAL v2 feature-case tests for execution, variable handling, and source attribution; Added Nacos MySQL schema initialization script for tests; Added benchmark tests for EBPF profiling, OpenAPI endpoint grouping, and URI matching performance; Added integration and unit tests for the Consul configuration module; Added integration and unit tests for the gRPC remote client module; Added integration tests for ZooKeeper dynamic configuration; Added integration tests for the etcd cluster plugin; Added mock LLM server and Spring AI client for GenAI e2e testing; Added test SPI configuration for LAL V2 source type provider; Added test for gRPC connection failure handling; Added test resources for Zookeeper configuration module integration tests; Added test resources for etcd configuration module; Added test service provider configuration for LayerExtension; Added test service provider files for Nacos configuration module; Added tests for DSL rule loading, line attribution, and debug gate logic; Added tests for EndpointTraffic serialization and persistence; Added tests for Feishu webhook alarm integration; Added tests for HTTP alarm callback status handling; Added tests for LAL rule loading, layer registration, and input-type routing; Added tests for LimitedSizeBufferedData; Added tests for OpenAPI-based endpoint name grouping; Added tests for PagerDuty alarm hook callback; Added tests for ServerStatusService config dump masking and extension handling; Added tests for ServiceTraffic grouping logic; Added tests for URI endpoint grouping and quick-match performance; Added tests for WeChat webhook alarm notifications and recovery messages; Added tests for eBPF profiling analysis; Added tests for endpoint grouping rule reading and dynamic configuration watching; Added tests for remote service handlers and HTTP server; Added tests for storage concurrency, persistence timing, and ID handling; Added tests for the MAL v2 compiler and runtime behavior; Added tests for trace sampling policy and uninstrumented gateway configuration; Added unit and integration tests for the Nacos cluster plugin; Added unit tests for ConfigmapConfigurationWatcherRegister; Added unit tests for DingTalk alarm webhook integration; Added unit tests for HistogramFunction; Added unit tests for Kubernetes cluster plugin provider and coordinator; Added unit tests for LatestFunction and LatestLabeledFunction meter analysis; Added unit tests for MeterEntity and MeterSystem; Added unit tests for MetricsQueryUtil label value composition; Added unit tests for OAL expression matchers; Added unit tests for OAPNodeChecker cluster health validation; Added unit tests for StandaloneManager; Added unit tests for SumPerMin and SumPerMinLabeled meter functions; Added unit tests for Tag equality logic; Added unit tests for UI template serialization; Added unit tests for WeLink alarm hook callback; Added unit tests for WebhookCallback alarm and recovery handling; Added unit tests for Zookeeper configuration watcher registration; Added unit tests for average meter functions; Added unit tests for component library catalog and searchable traces tags watcher; Added unit tests for configuration watcher registers; Added unit tests for core analysis components; Added unit tests for core metrics calculation logic; Added unit tests for core module configuration and infrastructure; Added unit tests for gRPC configuration synchronization; Added unit tests for max and min meter functions; Added unit tests for meter processing and converter registry; Added unit tests for query service utilities and hierarchy logic; Added unit tests for relation metrics equality logic; Added unit tests for runtime rule hot-update and worker suspension logic; Added unit tests for storage model definitions and installer behavior; Added unit tests for sum-based meter functions; Added unit tests for the LAL v2 class generator and compiler; Added unit tests for the OAL V2 engine generator and model components; Added unit tests for the alarm plugin core and notification hooks; Added unit tests for the gRPC metric exporter; Added unit tests for trace analyzer processors and segment status logic; Added unit tests for trace profiling query and stack analysis; Added v2-only MAL DSL execution tests; Enable inline mocking for tests; New Java e2e-service-provider fixture for end-to-end testing; New e2e-mock-sender service for E2E testing infrastructure.

The build system now centralizes dependency management through a new \oap-server-bom\ module, which defines versions for core libraries such as GraphQL, Armeria, and SnakeYAML. This BOM is imported by the new \apm-dist\ module to assemble the final distribution package. Additionally, the project structure has been modularized with the introduction of \apm-protocol\ and \apm-network\ for shared protocol definitions, alongside new analyzer modules for AI pipelines, agent conversations, and event analysis.

(dependencies) · high confidence

The project now uses the Maven Wrapper (version 3.1.0) to enforce a consistent build environment across all developers and CI systems. This change pins the underlying Apache Maven version to 3.8.4, ensuring that builds rely on a specific, tested version of the build tool rather than whatever is installed locally. This improves build reproducibility and performance while providing better native support for ARM architectures.

.mvn · high confidence

The protocol definitions in this module have been updated by syncing the underlying git submodule to commit 07882d5. This change pulls in the latest protocol schema changes defined in the external submodule repository, ensuring that the network data structures and service definitions used by this component remain consistent with the upstream protocol version.

apm-protocol/apm-network/src/main · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 70 → 75 (+4.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 77 → 86 (+8.9)
• Architecture 100 → 98 (-1.6)
• Maturity 78 → 78 (-0.0)
• Readiness 67 → 68 (+0.9)
• Security 66 → 80 (+13.6)

• Coverage not included — suite not readable by the collector
• DSLClassLoaderManager.sweepInternal (cognitive 23) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/classloader/DSLClassLoaderManager.java)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (oap-server/analyzer/agent-analyzer/src/main/java/org/apache/skywalking/oap/server/analyzer/provider/trace/parser/listener/EndpointDepFromCrossThreadAnalysisListener.java)
• Duplicated block (10 lines × 2) (oap-server/analyzer/agent-analyzer/src/main/java/org/apache/skywalking/oap/server/analyzer/provider/trace/parser/listener/EndpointSourceBuilder.java)
• Duplicated block (10 lines × 2) (oap-server/analyzer/agent-analyzer/src/main/java/org/apache/skywalking/oap/server/analyzer/provider/trace/parser/listener/RPCTrafficSourceBuilder.java)
• Duplicated block (10 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALClassGenerator.java)
• Duplicated block (10 lines × 2) (oap-server/exporter/src/main/java/org/apache/skywalking/oap/server/exporter/provider/kafka/log/KafkaLogExporter.java)
• Duplicated block (10 lines × 2) (oap-server/mqe-rt/src/main/java/org/apache/skywalking/mqe/rt/operation/LROp.java)
• Duplicated block (10 lines × 2) (oap-server/oal-rt/src/main/java/org/apache/skywalking/oal/v2/generator/OALClassGeneratorV2.java)
• Duplicated block (10 lines × 2) (oap-server/server-admin/runtime-rule/src/main/java/org/apache/skywalking/oap/server/receiver/runtimerule/rest/RuntimeRuleService.java)
• Duplicated block (10 lines × 2) (oap-server/server-alarm-plugin/src/main/java/org/apache/skywalking/oap/server/core/alarm/provider/expr/rt/AlarmMQEVisitor.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/MeterSystem.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/avg/AvgHistogramFunction.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/avg/AvgHistogramPercentileFunction.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/meter/function/avg/AvgLabeledFunction.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/worker/MetricsAggregateWorker.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/dsldebug/DslContentHash.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/remote/client/RemoteClientManager.java)
• Duplicated block (10 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/CiliumServiceInstanceRelation.java)
• …and 506 more

• AbstractBanyanDBDAO.topNQueryDebuggable (cyclomatic 16) (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/AbstractBanyanDBDAO.java)
• Analyzer.analyse (cognitive 29) (oap-server/analyzer/meter-analyzer/src/main/java/org/apache/skywalking/oap/meter/analyzer/v2/Analyzer.java)
• Analyzer.analyse (cyclomatic 23) (oap-server/analyzer/meter-analyzer/src/main/java/org/apache/skywalking/oap/meter/analyzer/v2/Analyzer.java)
• BanyanDBGenAIEvaluationRecordQueryDAO.queryGenAIEvaluationRecord (cognitive 37) (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBGenAIEvaluationRecordQueryDAO.java)
• BanyanDBGenAIEvaluationRecordQueryDAO.queryGenAIEvaluationRecord (cyclomatic 29) (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBGenAIEvaluationRecordQueryDAO.java)
• BanyanDBOTLPTraceQueryDAO.queryTraces (cognitive 27) (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBOTLPTraceQueryDAO.java)
• BanyanDBOTLPTraceQueryDAO.queryTraces (cyclomatic 19) (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBOTLPTraceQueryDAO.java)
• ClassTooLong: AccessLogServiceHandler (oap-server/server-receiver-plugin/skywalking-ebpf-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/ebpf/provider/handler/AccessLogServiceHandler.java)
• ClassTooLong: BanyanDBClient (oap-server/server-library/library-banyandb-client/src/main/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBClient.java)
• ClassTooLong: BanyanDBIndexInstaller (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBIndexInstaller.java)
• ClassTooLong: DebuggingHTTPHandler (oap-server/server-admin/status/src/main/java/org/apache/skywalking/oap/server/admin/status/DebuggingHTTPHandler.java)
• ClassTooLong: LALValueCodegen (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
• ClassTooLong: MALClosureCodegen (oap-server/analyzer/meter-analyzer/src/main/java/org/apache/skywalking/oap/meter/analyzer/v2/compiler/MALClosureCodegen.java)
• ClassTooLong: MALScriptParser (oap-server/analyzer/meter-analyzer/src/main/java/org/apache/skywalking/oap/meter/analyzer/v2/compiler/MALScriptParser.java)
• ClassTooLong: MQEVisitorBase (oap-server/mqe-rt/src/main/java/org/apache/skywalking/mqe/rt/MQEVisitorBase.java)
• ClassTooLong: MetadataRegistry (oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/MetadataRegistry.java)
• ClassTooLong: PromQLApiHandler (oap-server/server-query-plugin/promql-plugin/src/main/java/org/apache/skywalking/oap/query/promql/handler/PromQLApiHandler.java)
• ClassTooLong: PromQLExprQueryVisitor (oap-server/server-query-plugin/promql-plugin/src/main/java/org/apache/skywalking/oap/query/promql/rt/PromQLExprQueryVisitor.java)
• ClassTooLong: RunningRule (oap-server/server-alarm-plugin/src/main/java/org/apache/skywalking/oap/server/core/alarm/provider/RunningRule.java)
• ClassTooLong: SampleFamily (oap-server/analyzer/meter-analyzer/src/main/java/org/apache/skywalking/oap/meter/analyzer/v2/dsl/SampleFamily.java)
• …and 1055 more

• 36 commits — 28 feature/other, 8 fixes

• oap-server/analyzer — 11 commits
• docs/en — 8 commits
• test/e2e-v2 — 6 commits
• oap-server/server-library — 3 commits
• oap-server/server-storage-plugin — 3 commits
• oap-server/server-admin — 2 commits
• oap-server/server-core — 1 commit
• oap-server/server-query-plugin — 1 commit
• oap-server/server-receiver-plugin — 1 commit

• fix: Add ThreadPolicy.ioBound for blocking consumers, fix BatchQueue shutdown (#13979)
• fix: Fix APISIX monitoring guide configuration and metrics (#13976)
• fix: Fix JDBC reads missing the second day of a range shorter than a day that crosses midnight (#14061)
• fix: Fix LAL segmentId/spanId extractor statements; delete dead DSL code and correct the kernel's docs (#13973)
• fix: Fix a persistence round ending before the storage answered (#14060)
• fix: Fix filtering events by layer on the Elasticsearch storage (#14087)
• fix: Fix generated-class source attribution in MAL, LAL and OAL (#13971)
• fix: Fix the OTLP TraceQL search result types and the BanyanDB name catalogs' time bound (#14099)
• change: SWIP-16 Support LLM-as-Judge on Top of GenAI Observability (#13943)
• change: AI agent conversations: provider bodies in the view, and files over HTTP (#14084)
• change: Add AI agent conversations landed by the AI Sessionizer (#14057)
• change: Add BanyanDB trace tail sampling monitoring (#14052)
• change: Add OpenTelemetry-native host and process monitoring (#14051)
• change: Add Spring LDAP component definitions (#13984)
• change: Add a none provider to the ai-agent-conversation module (#14064)
• change: Adopt AI Sessionizer workspace changes and agent runtime metrics (#14063)
• change: Apply max request header size config to HTTP/2 as well (#14062)
• change: Bump the default BanyanDB compatible server API version (SW_STORAGE_BANYANDB_COMPATIBLE_SERVER_API_VERSIONS) from 0.10 to 0.11. (#13997)
• change: Drop runtime-rule's retired-IT dependencies and declare server-testing at test scope (#13977)
• change: Fail fast when the e2e docker targets run on a JDK older than 17 (#14072)
• …and 16 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

apache/skywalking was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.