Skip to content
CAI
Software that uses CAICheck a score

apache/skywalking

64.0

Adequate · 13 November 2026

243.3k

lines of production code

Java

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

AI agent conversation view endpoint and data format parsers

The AI agent conversation analyzer now exposes a new HTTP endpoint at /ai-agent/conversations/{conversation}/v1/view that streams the complete conversation as an asz.view 1.0 document in JSON or YAML format. This view is built using newly added format parsers in the format package that decode Session Data (.sd) files and Session Flow (.sf) rounds, including specific record types for tool changes (ChangesRecord) and tool executions (ExecutionRecord), along with schema definitions and reference handling to structure the conversation data for retrieval.

ai-agent-conversation · high confidence

Add AWS Firehose receiver for OpenTelemetry metrics

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

Add Apollo dynamic configuration support

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

Add Async Profiler receiver plugin for JFR data ingestion

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

Add CLR receiver plugin for .NET runtime metrics

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

Add Configuration Discovery receiver plugin for agent dynamic settings

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

Add Consul as a dynamic configuration center

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

Add Consul as a dynamic configuration center

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-zookeeper/src/main · high confidence

Add Envoy v3 and OpenTelemetry protocol definitions for receiver support

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

Add Go language support to trace profiling

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

Add Kubernetes cluster manager plugin

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

Add Nacos as a dynamic configuration center option

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

Add OpenAI-compatible LLM-as-Judge provider for AI evaluation

The AI evaluation module now supports using external LLMs as judges via a new OpenAI-compatible provider. This change introduces the OpenAICompatibleProvider class, which handles HTTP communication with configurable endpoints, API keys, and models. It includes robust error handling with configurable timeouts, retry logic, and temperature settings, enabling users to leverage third-party LLM services for automated evaluation tasks within the SkyWalking AI evaluation framework.

ai-evaluation · high confidence

Add UidEnvSupplier for Kubernetes cluster node identification

The Kubernetes cluster plugin now includes a new UidEnvSupplier class that retrieves the node's unique identifier from a configurable environment variable. This component enables the cluster plugin to dynamically obtain the UID required for node identification in Kubernetes environments.

cluster-kubernetes-plugin · high confidence

Add Zabbix protocol decoder for incoming data

The Zabbix receiver plugin now includes a new protocol decoder that validates the Zabbix binary header (ZBXD) and parses incoming JSON request payloads. This enables the SkyWalking OAP server to correctly receive and process data sent via the Zabbix protocol, handling header validation, payload extraction, and error handling for malformed requests.

skywalking-zabbix-receiver-plugin · high confidence

Add Zabbix receiver plugin

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

Add Zipkin source entity definitions for trace data ingestion

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

Add browser error log recording and dispatching

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

Add eBPF process profiling storage and dispatching

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

Add etcd as a dynamic configuration source

Users can now configure the OAP server to fetch dynamic configuration from an etcd cluster. This change introduces the etcd configuration module, including settings for endpoints, namespace, authentication, and polling period, allowing the server to read and watch configuration keys stored in etcd.

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

Add etcd-based cluster coordination plugin

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

Add gRPC-based dynamic configuration synchronization

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

Add iOS/iPadOS app monitoring via OpenTelemetry Swift SDK

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 Service, ServiceInstance, and Endpoint sources under the IOS layer, while IOSMetricKitSpanListener converts daily MetricKit payloads into MAL metrics for app launch time, hangs, CPU/GPU usage, memory, disk I/O, network transfer, abnormal exits, and scroll hitch ratios. These listeners are registered via the Java SPI mechanism to process incoming OTLP spans.

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

Add instance traffic metrics for service instances

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

Add library-util utility classes

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

Add mock core module provider for profile exporter tool

The profile exporter tool now includes a mock implementation of the core module provider (\MockCoreModuleProvider\) to support standalone profiling operations. This new component registers essential services such as profiling query and mutation services (for trace, async, continuous, eBPF, and pprof profiling), caching mechanisms, and various query services (metrics, trace, topology, alarms) using mock implementations for network and remote communication, enabling the tool to function without a full OAP server backend.

tool-profile-snapshot-server-mock · high confidence

Add mock module for profile exporter tooling

A new mock module has been added to the profile-exporter tooling to support development and testing without a full backend. This includes a configuration class, a service provider registration, and several mock implementations (for component library catalog, gRPC/HTTP handler registration, remote client management, source reception, stream annotation listening, and worker instances) that replace real services with no-op or stub versions.

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

Add pprof profile data parsing and analysis library

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

Add process-level client and server side metrics for service topology

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

Add server-side endpoint call relation metrics for Cilium/Hubble observability

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

Add service call relation metrics and dispatchers for TLS, TCP, K8s, and Cilium

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

Add service instance call relation metrics and dispatchers

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

Add service-dimension aggregation for slow database statements

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

Add slow cache command analysis for read and write operations

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

Add standalone cluster plugin for single-node deployments

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

Add sumPerMin and sumPerMinLabeled meter functions

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

Add support for latest and labeled latest meter functions

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

Added SQL query model classes for grouping and filtering

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

Added max and min aggregation functions for meter metrics

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

Added storage interfaces for runtime rules and UI templates

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

Alarm plugin adds MQE support and new webhook integrations

The alarm plugin now supports the MQE query language for defining alarm rules, including a new AlarmKernel that resets rule windows when affected metrics change semantics, and an MQE visitor that captures metric snapshots. Additionally, the plugin introduces new webhook integrations for Discord and WeLink, while refactoring existing Slack, WeChat, and generic Webhook callbacks to use a common HttpAlarmCallback base class with improved error handling and template support.

server-alarm-plugin · high confidence

Backend support for browser protocol traffic handling

The OAP server now includes core infrastructure to process browser protocol data. This change adds a dispatcher for browser application traffic that filters out non-normal traffic categories before processing, and introduces a backend-side sampling mechanism for browser error logs to control ingestion volume based on a configurable sample rate.

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

Backend-side dynamic trace sampling by service dimension

The agent-analyzer now performs trace sampling on the backend side using a new \TraceSamplingPolicyWatcher\ and \TraceSegmentSampler\. This allows sampling rates to be configured dynamically per service via configuration changes, rather than relying solely on static defaults or agent-side decisions. The sampling decision uses the absolute hash of the trace ID to determine if a segment falls within the configured rate, while also considering duration thresholds for slow traces.

agent-analyzer · high confidence

Background Kubernetes metadata lookup with non-blocking caching

The library now introduces a \LookupCache\ component that reads Kubernetes metadata asynchronously in the background. This allows data analysis threads to retrieve cached metadata immediately without blocking on API server latency, while pending reads are shared and queued efficiently. The cache supports configurable refresh, expiration, and retry periods for both found and not-found entries, ensuring that lookups do not wait indefinitely for slow API responses.

library-kubernetes-support · high confidence

Browser traffic is now dispatched to service instance metrics

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

Browser traffic metrics are now dispatched to the Service layer

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

Centralized command factory for profiling task distribution

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

Delegated health checker for flexible client health management

A new DelegatedHealthChecker class has been added to the library-client module, implementing the HealthChecker interface to allow runtime swapping of the underlying health check implementation. This enables components to register a specific health checker and delegate health status updates to it, supporting more dynamic health monitoring strategies without requiring static configuration.

library-client · high confidence

Dynamic logging configuration support

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

Elasticsearch storage refactors to support merged tables and eBPF profiling

The Elasticsearch storage plugin introduces a new \ElasticSearchConverter\ to automatically handle column aliasing for merged index models, ensuring compatibility between logic-sharding and non-sharding storage configurations. It adds dedicated Data Access Objects for eBPF profiling (tasks, schedules, and data) and service/instance hierarchy queries, enabling the storage and retrieval of continuous profiling data. Additionally, the plugin implements a \HistoryDeleteEsDAO\ to optimize the Time-To-Live (TTL) mechanism by skipping already-processed indices, and adds wrappers for metric index requests to support session cache callbacks.

storage-elasticsearch-plugin · high confidence

Envoy access log receiver now supports TCP traffic metrics

The Envoy metrics receiver plugin has been extended to process TCP access logs in addition to HTTP. New adapter classes (LogEntry2MetricsAdapter and TCPLogEntry2MetricsAdapter) parse Envoy v3 AccessLogService data, extracting metrics such as TLS mode, internal error codes, latency, and byte counts for both HTTP and TCP workloads. This enables visibility into TCP service mesh traffic that was previously not captured by the ALS-based metrics pipeline.

envoy-metrics-receiver-plugin · high confidence

Envoy metrics receiver plugin restructured with v3 protocol support and LAL integration

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

Etcd configuration module registration restored

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

Initial exporter provider implementation with gRPC and Kafka support

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

Initial implementation of Consul-based cluster coordination

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

Initial repository scaffolding and project configuration

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

Initial service mesh telemetry receiver plugin

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

Internal OAP query execution tracing infrastructure

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

Introduce AI Pipeline module for HTTP URI recognition and baseline prediction

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

Introduce AI agent conversation module with configurable data retention and privacy controls

The new \ai-agent-conversation\ module enables the ingestion and querying of long-lived AI agent conversations landed by the AI Sessionizer. It provides HTTP endpoints to retrieve conversation views and associated data files, with configurable limits on list size, request timeouts, and response sizes to manage performance. Operators can also configure a \hide\ setting to mask sensitive content, such as system prompts and tool schemas, from all readers at query time without removing the data from storage.

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

Introduce BatchQueue library for metrics pipeline

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

Introduce Event query model and query conditions

The server-core module now includes the data model and query condition classes for the new Event concept. This adds the \Event\ POJO (containing fields like uuid, source, name, type, message, parameters, timestamps, and layer), the \EventQueryCondition\ for filtering and pagination, and supporting enums/types \EventType\ and \Source\. This change provides the backend query structure required to retrieve and filter events, complementing other changes that define event collection and storage.

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

Introduce GenAI Analyzer module for virtual GenAI observability

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

Introduce GenAI Observability AI Evaluation module

Adds a new AI evaluation module that enables LLM-as-Judge evaluation on GenAI spans. The module introduces a new configuration file (ai-evaluation.yml) to define sampling rates, buffer sizes, judge provider settings (currently supporting OpenAI-compatible providers), system prompts, and evaluation tasks. It includes a span listener that intercepts GenAI spans (both OTLP and Zipkin), extracts relevant context (input/output messages, model info), and samples them for evaluation. The evaluation pipeline plans tasks, builds prompts with content truncation and security measures, sends requests to the configured judge model, and parses results into evaluation outcomes with configurable score levels and boolean mappings.

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

Introduce GenAI evaluation record model and query service

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

Introduce Kafka Fetcher Plugin for Telemetry Ingestion

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

Introduce LAL V2 engine with ANTLR4 code generation and live debugging

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

Introduce LAL v2 compiler with ANTLR4 parsing and Javassist bytecode generation

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

Introduce LogQL HTTP query API support

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

Introduce MAL-based meter processing with hot-swappable rule support

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Introduce Trace Analysis Language (TAL) for OTLP trace-to-metrics conversion.

oap-server/analyzer/agent-analyzer/src/main · medium confidence · unverified

Introduce MQE runtime engine for metrics and trace querying

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

Introduce NetworkAddressAlias metric model and storage mapping

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

Introduce Prometheus telemetry exporter with SSL support

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

Introduce ServiceTraffic metrics and dedicated dispatchers for service traffic analysis

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

Introduce TopN record model with storage annotations

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

Introduce TraceQL plugin with Tempo API compatibility and native OTLP support

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

Introduce Zipkin Query plugin with TLS support and cold-stage query capability

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

Introduce continuous profiling policy management and validation

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

Introduce core alarm module with recovery notifications and metrics snapshots

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

Introduce core exporter module and service interfaces

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

Introduce dedicated Event record and LongText storage support

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

Introduce dedicated JVM receiver plugin with v3 protocol support

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

Introduce dynamic configuration API and module

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

Introduce eBPF Profiling mutation and query services

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

Introduce eBPF Receiver plugin for access logs and profiling

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

Introduce eBPF profiling data storage interfaces

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

Introduce granular TTL configuration and status query for storage backends

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

Introduce histogram and percentile support in the meter system

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

Introduce library-server with Armeria HTTP and gRPC server implementations

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

Introduce new Meter Receiver plugin for gRPC meter data ingestion

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

Introduce new Zipkin receiver module with HTTP and Kafka support

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

Introduce new log record model and dispatching infrastructure

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

Introduce optional dedicated sharing server for receiver traffic

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

Introduce pprof profiling support in the server core

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

Introduce process detection type and service label tracking

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

Introduce server-side async profiler task management and JFR data storage

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

Introduce tag autocomplete data storage model

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

Introduce telemetry API module with metrics and health check interfaces

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

Introduce unified client library with health checks and new request abstractions

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

Introduces MQE query result data models

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

Introduces OAL V2 engine with ANTLR4 parsing and Javassist code generation

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

Introduces core server interfaces and gRPC token authentication

This change adds the foundational server interfaces \GRPCHandlerRegister\ and \HTTPHandlerRegister\ to the core module, establishing the contract for registering gRPC services and HTTP handlers (specifically supporting method filtering via Armeria's \HttpMethod\). It also introduces \AuthenticationInterceptor\, a gRPC server interceptor that enforces token-based authentication by validating an expected token against the incoming 'Authentication' metadata header, returning a PERMISSION\_DENIED status if the token does not match.

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

Introduces custom gRPC health check handler for OAP server

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

Introduction of OAL V2 engine runtime components

The OAL runtime now includes the core implementation for the V2 engine, introducing a new ANTLR-based parser (OALScriptParserV2) to process OAL scripts into structured metric definitions. This update adds model classes for typed filter values and function arguments, alongside a definition enricher that prepares metric metadata for code generation, enabling the new rule processing capabilities.

oal-rt · high confidence

Introduction of StreamData base class for cross-node aggregation

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

Live DSL debugging for LAL and MAL rules

The admin server now supports live debugging sessions for Log Analysis Language (LAL) and Meter Analysis Language (MAL) rules. This change introduces cluster-aware session management (install, collect, stop) and DSL-specific debug recorders that capture per-step execution samples—including input payloads, filter outcomes, and terminal outputs—along with the verbatim DSL source text for each step. For LAL, the recorder supports both block-level and statement-level granularity, and explicitly surfaces the drop reason when a pipeline execution is aborted. For MAL, the recorder captures the full post-filter survivor map and tracks downsampling annotations to provide clear visibility into how metrics are processed and emitted.

dsl-debugging · high confidence

Live DSL debugging support for MAL and LAL rules with cluster-wide session management

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

Nacos cluster plugin adds internal communication and authentication configuration

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

Native OTLP trace storage and cataloging

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

Native OTLP trace storage and unified OTLP receiver architecture

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

New Cilium network traffic fetcher plugin

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

New DAO interfaces for trace profiling data access

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

New DSL and module testing utilities for LAL, MAL, and Hierarchy rules

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

New Docker image for the OAP server

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

New JFR parser library for async-profiler data

The \library-async-profiler-jfr-parser\ module now includes a new Java-based parser that converts async-profiler JFR files into SkyWalking-compatible flame graph data. This library introduces classes to read JFR events (execution samples, allocations, locks, live objects), aggregate them, and build frame trees with support for thread and classification options, enabling the server to ingest and visualize async-profiler performance profiles.

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

New Kubernetes ConfigMap configuration provider

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

New OAL engine annotation definitions for metrics and filtering

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

New OAL expression matchers for boolean, numeric, and string filtering

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

New SPIs for typed LAL input handling and debug rendering

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

New SpanListener SPI for intercepting and modifying trace spans

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Introduce Trace Analysis Language (TAL) for OTLP trace-to-metrics conversion.

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

New Telegraf receiver plugin for ingesting metrics via HTTP

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

New Trace Analysis Language (TAL) compiler and meter functions for OTLP trace analysis

The trace analyzer now includes the Trace Analysis Language (TAL) compiler infrastructure, introducing TALScriptModel and TALSpanRootResolver to parse and compile TAL rules that analyze OTLP traces into metrics and topology. To support these new TAL-generated metrics, the server core adds ApdexFunction and PercentFunction, which implement the Apdex and percentage-based meter functions required by the TAL rule engine.

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

New admin-only Inspect API for browsing metrics and entities

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

New admin-server module with internal gRPC and TLS support

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

New browser performance and traffic data models

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

New browser receiver plugin for collecting performance data and error logs

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

New caching layer for async and pprof profiling tasks

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

New cluster core framework and health checking logic

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

New configuration policies and statistics for BatchQueue

The BatchQueue library now exposes three new classes to control its behavior: ThreadPolicy allows configuring the drain thread pool with fixed, CPU-proportional, or I/O-bound (ioBound) modes, enabling virtual threads for blocking consumers; PartitionPolicy provides fixed, thread-multiplier, or adaptive strategies to determine partition counts based on handler registrations; and BatchQueueStats offers an immutable snapshot of queue usage, including total capacity, per-partition usage, and top-N most-loaded partitions for monitoring.

library-batch-queue · high confidence

New core configuration services for component mapping, hierarchy, and naming

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

New data models for AI agent session and conversation flow records

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

New data-generator Docker image for testing

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

New data-generator module for creating mock telemetry data

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

New data-generator module with typed mock data generators

The data-generator module has been introduced to produce mock data for testing OAP in testing mode. This update adds a suite of typed generators—BoolGenerator, FixedStringGenerator, IntGenerator, ListGenerator, StringGenerator, and UUIDGenerator—each implementing the Generator interface with builder-based configuration. These components allow users to generate specific types of mock data (booleans, fixed strings, integers with range/domain constraints, lists, strings with prefixes/character sets, and UUIDs with controlled change frequency) to support testing scenarios.

data-generator · high confidence

New endpoint traffic metrics and dispatchers for unified endpoint analysis

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

New enumeration types for GenAI, profiling, and query sorting

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

New event receiver plugin for collecting application events

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

New event-analyzer module for processing event data

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

New gRPC metric exporter protocol definition

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

New health-checker module exposes OAP server status via HTTP

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

New modular core framework for OAP server initialization

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

New network protocol commands for profiling and configuration discovery

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

New pprof profiling receiver plugin

The SkyWalking OAP server now includes a new receiver plugin for the pprof profiling protocol. This feature allows the server to receive profiling data from agents via gRPC, supporting both in-memory parsing and temporary file-based collection based on the new \memoryParserEnabled\ configuration (defaulting to true). The plugin registers a gRPC handler to process pprof data streams, parses the profiling information into frame trees, and stores the results for analysis.

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

New profile exporter tool and TLS key generation utility

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

New profile snapshot exporter tool for offline analysis

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

New profile task receiver plugin for OAP server

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

New query DAO interfaces for AI agent conversations, GenAI evaluation, and alarm entity filtering

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

New query input models for alarms, profiling, and GenAI evaluation

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

New query types for async profiling, continuous profiling, and alarms

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

New remote client selection strategies

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

New sampled trace record models for slow, 4xx, and 5xx traces

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

New segment record model and dispatcher for trace data

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

New server status service with booting, cluster, and config-dump extension capabilities

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

New source models for Cilium, cache, database, and eBPF profiling

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

New standalone log receiver plugin with gRPC and HTTP endpoints

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

New status module provides admin-endpoint debugging and cluster status queries

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

New storage query interfaces for Async Profiler data

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

New sum-based meter functions for labeled and histogram metrics

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

New thread-analysis benchmark for OAP thread dump diagnostics

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

New thread-safe buffering and caching infrastructure for metrics data

The server introduces a new data buffering layer in the core analysis module to improve concurrency handling during metrics aggregation. This includes the \BufferedData\ interface and \MergableBufferedData\ implementation, which allows incoming metrics with identical IDs to be combined (merged) before storage, reducing redundant data processing. Additionally, a new \ReadWriteSafeCache\ class provides a thread-safe, double-buffering mechanism using a \ReentrantLock\ to isolate read and write operations, enabling safer concurrent access to metric data streams.

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

New v8 management receiver plugin for instance registration

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

New v8 trace receiver plugin with span attached event support

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

Persisted storage for runtime-managed MAL and LAL rules

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

Prometheus telemetry server now supports SSL/TLS

The Prometheus telemetry HTTP server in the OAP server now supports encrypted connections. A new HttpServerInitializer component conditionally adds an SSL handler to the Netty pipeline when an SslContext is provided, enabling secure scraping of metrics by Prometheus fetchers.

telemetry-prometheus · high confidence

Runtime rules can declare dynamic layers and are applied via a unified, atomic DSL pipeline

Operators can now define custom layers in MAL and LAL runtime rules, which are registered dynamically at runtime and managed via a new in-memory reference-counted registry that ensures safe addition, replacement, and removal. The runtime-rule module now uses a unified, two-phase apply pipeline (compile-then-register) for both MAL and LAL files, ensuring that if compilation fails, no partial state is left behind and any previously registered layers are rolled back. This change also introduces a database-backed override resolver that applies operator-defined rule overrides at boot, ensuring that runtime changes persist across restarts without regressing to static disk content.

runtime-rule · high confidence

Server-side eBPF profiling analysis engine

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

Server-side support for UI template management

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

Service and Instance Hierarchy auto-matching support

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

Service provider configuration for core modules and providers

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

Support exporting Trace and Log data to Kafka

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

Support for SkyWalking and Zipkin span-attached events

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

Support for browser app page traffic metrics

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

Support for endpoint name grouping based on OpenAPI definitions

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

Unified DSL source attribution and dynamic layer support

The server-core module now provides a unified mechanism for tracking the origin of DSL rules (OAL, MAL, LAL, and Hierarchy) through the new DslSourceRef and DslYamlLineIndex classes, ensuring accurate file and line attribution for debugging and error reporting. Additionally, the Layer registry has been expanded to support dynamic, runtime-defined layers via hot-update rules, allowing operators to introduce custom layers without modifying OAP source code or restarting the server.

server-core · high confidence

Zipkin module adds BanyanDB IndexMode metrics and span record models

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

Zookeeper cluster plugin adds custom instance serializer

The Zookeeper cluster plugin now includes a new SWInstanceSerializer class that handles serialization and deserialization of RemoteInstance objects using Gson. This serializer converts ServiceInstance objects to/from JSON bytes, enabling proper instance registration and discovery within the Zookeeper-based cluster communication.

cluster-zookeeper-plugin · high confidence

Zookeeper cluster plugin adds namespace and ACL support

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

Architecture

Elasticsearch storage plugin restructured with new configuration and base DAO classes

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

Behavioural changes

4 commits (0 fixes) modifying trace-analyzer

A change to existing behaviour in trace-analyzer — 4 commits, 4 files: “Move the native trace analysis from Java listeners to TAL rules (SWIP-17) (\#14208)”; “Add the Trace Analysis Language (TAL) to analyze OTLP traces into metrics and topology (\#14129)”; “Analyze OTLP spans opt-in by service.layer, and file the OTLP service catalog by layer (\#14170)”; and 1 more (refs \#14208, \#14129, \#14170, \#14183).

trace-analyzer · medium confidence · unverified

9 commits (1 fix) modifying oap-server/analyzer/trace-analyzer

A change to existing behaviour in oap-server/analyzer/trace-analyzer — 9 commits (1 fix), 124 files: “Move the native trace analysis from Java listeners to TAL rules (SWIP-17) (\#14208)”; “Add the Trace Analysis Language (TAL) to analyze OTLP traces into metrics and topology (\#14129)”; “Count a TAL consumer's receive span that has a parent as its request (\#14179)”; and 6 more (refs \#14208, \#14129, \#14179, \#14153, \#14209, …).

oap-server/analyzer/trace-analyzer · medium confidence · unverified

BanyanDB storage plugin rewritten with native Java client and new data models

The BanyanDB storage plugin has been completely rewritten to replace the previous Java client with a native implementation, introducing new data models and DAOs for metrics, traces, and logs. This change brings support for hot/warm/cold data stages, allowing users to query cold-stage data for metrics, traces, and logs. It also introduces a new Trace model with support for specifying spanId and internal debugging via MQE queries. Additionally, the plugin now supports custom TopN pre-aggregation rules, new index rule types (SKIPPING/TREE), and the ability to update group settings and schemas at OAP startup. The metadata query DAOs have been updated to support service hierarchy, instance queries with time ranges, and endpoint searches with keyword matching. The plugin also adds support for eBPF profiling data and span attached events, improving the overall observability and debugging capabilities for users.

storage-banyandb-plugin · high confidence

BanyanDB storage plugin rewritten with native client and new architecture

The BanyanDB storage plugin has been completely rewritten to replace the previous Java client with a native implementation, introducing a new set of Data Access Objects (DAOs) such as BanyanDBAggregationQueryDAO, BanyanDBBatchDAO, and BanyanDBRecordsQueryDAO. This change brings server-side TopN support for metrics, enables cold-stage data queries for metrics, traces, and logs, and introduces a new configuration loading mechanism via bydb.yml and bydb-topn.yml files. Additionally, the plugin now exposes its configuration via the /debugging/config/dump endpoint through a new ConfigDumpExtension, and implements a new batch write architecture with dedicated bulk processors for streams, measures, and traces.

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

Centralized integration test version management and BanyanDB container configuration

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

Centralized storage model management with backend-specific extensions

The OAP server's storage model layer has been refactored to centralize model definitions and introduce backend-specific metadata extensions. New classes \BanyanDBModelExtension\ and \ElasticSearchModelExtension\ allow models to carry backend-specific configuration, such as BanyanDB timestamp and trace/span ID columns, index modes, and Elasticsearch routing fields. The \Model\ class now aggregates these extensions alongside standard metadata like downsampling and scope. A new \ModelRegistry\ interface and \ModelInstaller\ abstract class manage the lifecycle of these models, introducing a \StorageManipulationOpt\ system that distinguishes between schema-changing operations (e.g., operator-driven REST updates) and non-changing operations (e.g., peer-node reconciliation or static boot-time registration). This enables stricter control over when and how storage resources (tables, indices, measures) are created, updated, or dropped, particularly supporting 'no-init' modes where schema changes are deferred to a designated init node.

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

Deprecate legacy MetricQuery resolver and add LogAdapter for log parsing

The legacy MetricQuery GraphQL resolver is now deprecated and delegates to the newer MetricsQuery implementation, maintaining backward compatibility for existing metric queries while signaling the transition to the new protocol. Additionally, a new LogAdapter type has been introduced to parse raw log entries, extracting timestamps and content from log lines formatted with RFC3339 timestamps, enabling proper display of log data in the GraphQL API.

query-graphql-plugin · high confidence

Endpoint names are grouped using a new quick-match URI pattern engine and dynamic configuration

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

GraphQL query engine now supports asynchronous execution and query complexity limits

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

Hierarchy rules now use a high-performance ANTLR4 and Javassist compiler instead of the Groovy runtime

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

Introduce MQE-based alarm kernel with dynamic rule management and multi-channel notification support

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

Introduce new OAP server startup and configuration bootstrap mechanism

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

Introduce new gRPC-based remote streaming protocol for OAP cluster communication

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

Introduces new storage type conversion interfaces

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

Introduction of the OAL V2 Runtime Engine

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

JDBC storage now uses asynchronous batch writing for improved performance

The JDBC storage plugin has been refactored to support asynchronous batch persistence. A new \JDBCBatchDAO\ implementation introduces a \BatchQueue\ to buffer and asynchronously flush write operations, while a new \BatchSQLExecutor\ handles the actual batching of SQL statements. This change replaces the previous synchronous write path, significantly improving write throughput for metrics and records stored in JDBC backends.

storage-jdbc-hikaricp-plugin · high confidence

JDBC storage plugin refactored with new batch execution and table management infrastructure

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

Log Analysis Language (LAL) grammar redefined with new syntax features

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

Log Analysis Language (LAL) v2 engine introduces new DSL execution model

The log-analyzer module now uses a new LAL v2 engine, replacing the previous Groovy-based DSL runtime with an ANTLR4 + Javassist implementation. This change introduces a new immutable AST model (LALScriptModel) for parsing scripts, new parser specifications (such as TextParserSpec) that handle log body extraction with configurable abort-on-failure behavior, and new sampling mechanisms (like PossibilitySampler) for controlling log volume. Users will experience a different underlying execution environment for their log analysis rules, with improved parsing reliability and new capabilities for local variable declaration and JSON parsing within text log bodies.

log-analyzer · high confidence

Log Analyzer V2 module registration

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

Log analysis pipeline refactored to layer-based listener architecture

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

Log-analyzer v2 engine introduces hot-updatable LAL/MAL rules and dynamic layer support

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

MQE query language grammar expanded with new functions and operators

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

Meter Analysis Language (MAL) engine upgraded to v2 with ANTLR4 and Javassist

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

Meter system now supports service-level metrics with additional attributes

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

Meter-analyzer v2 engine introduces new runtime components for metric conversion and Kubernetes context

The meter-analyzer module adds the core runtime classes for the new v2 engine: MetricConvert now orchestrates a two-phase (prepare then register) lifecycle for MAL rules, ensuring that compilation errors do not leave partially provisioned metrics in storage; SampleFamily gains a structured debugDump() method for detailed DSL debugging; CounterWindow implements the sliding-window logic for counter increase and rate calculations; and K8sInfoRegistry provides a cached lookup of Pod-to-Service mappings using the Kubernetes client library.

meter-analyzer · high confidence

Migrate Kubernetes client library to Fabric8 with optimized resource caching

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

Native BanyanDB client library replaces Java SDK

The BanyanDB client in the server library has been replaced with a native Java implementation, removing the previous external Java SDK dependency. This new client provides a fluent API for building queries (including measure, property, and trace models) and handling writes, and introduces support for ordering query results via an OrderBy clause.

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

Native BanyanDB client with hot-reloadable TLS and credentials

The library-banyandb-client now uses a native Java implementation instead of the previous Java client. This new client supports hot-reloading of BanyanDB credentials and TLS trust CAs, allowing seamless certificate rotation and credential updates without restarting the service. The implementation includes new components like MeasureWrite for building metric write requests, TagAndValue for handling tag data types, and ChannelManager for managing gRPC channel lifecycle and refresh.

library-banyandb-client · high confidence

New OAL Runtime Engine grammar with expanded sources and filter capabilities

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

New core analysis infrastructure and extensibility mechanisms

The OAP server core analysis module has been refactored to introduce a new, extensible foundation for metrics and source processing. This change adds a \ConfigurationDictionary\ interface and \ApdexThresholdConfig\ to support dynamic, YAML-based configuration lookups for metrics like Apdex. It introduces a \LayerExtension\ SPI and \LayerExtensionLoader\ to allow operators to register custom service layers via \layer-extensions.yml\ or ServiceLoader plugins without modifying OAP source code. The analysis pipeline is now driven by a new \DispatcherManager\ that routes \ISource\ events to \SourceDispatcher\ implementations, and a \SourceDecoratorManager\ that allows decorating sources (e.g., filling \attr0-4\) before processing. New annotations like \@Stream\, \@MetricsExtension\, \@Disable\, and \@MultipleDisable\ define stream metadata, processing behavior, and entity disabling, while \IDManager\ provides centralized ID encoding/decoding for services, instances, and relations.

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

New internal gRPC protocols for remote service communication and span storage

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

OAP startup scripts updated for version 11.0.0 with increased default memory and UI removal

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

OAP version information is now exposed via logs and a new query

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

Rebuilt Elasticsearch client on top of Armeria REST API

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

Rebuilt Elasticsearch client on top of the REST API

The Elasticsearch client library has been completely rewritten to communicate directly with the Elasticsearch REST API using the Armeria HTTP client, replacing the previous transport-layer implementation. This new architecture introduces a modular client structure with dedicated components for managing templates, indices, documents, aliases, and search operations, and includes support for configurable response timeouts, basic authentication, and automatic retry logic.

library-elasticsearch-client · high confidence

Refactor OAP cluster communication with new RemoteClient architecture

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

Refactored core metrics classes and introduced new metric types

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

Refactored meter function storage and serialization to use DataTable and StorageID

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

Refactored metrics pipeline to use BatchQueue with adaptive partitioning and separated OAL/MAL processing

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

Refactored storage annotations and added foreign metric metadata support

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

Refactored storage persistence layer with new DAO interfaces and batch processing

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

Refactored worker instance management with hot-update support

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

Register Exporter module provider for service discovery

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

Runtime rule hot-update for MAL and LAL via dynamic layer overrides

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

Runtime rule updates now classify changes to skip unnecessary restarts and reset only affected alarms

The runtime-rule module now distinguishes between structural changes (new, removed, or shape-altered metrics) and filter-only updates (body/tag changes that do not affect storage). When only filters change, the system applies the update without restarting metric pipelines or resetting alarm windows, reducing operational noise and downtime. For structural changes, alarm windows are reset only for the specific metrics that were added, removed, or had their shape changed, rather than resetting all alarms globally.

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

Strict TraceQL query parsing with explicit error handling

The traceql-plugin now uses a new TraceQLQueryParser and TraceQLQueryVisitor to strictly parse TraceQL queries, rejecting unsupported constructs like OR (\|\|), negation (!), attribute existence checks, and multiple spansets with clear error messages instead of silently returning unfiltered traces. Supported filters are mapped to specific query parameters (service name, span name, status, kind, duration, and tags), ensuring that queries behave predictably and securely.

traceql-plugin · high confidence

Unified DSL class naming, source attribution, and loader lifecycle management

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

Unified gRPC metrics exporter with labeled metric support

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

Updated release documentation with current license and notice files

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

Watermark-based circuit breaking for gRPC requests

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

Test coverage

1 commit adding/updating tests in oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/manual/networkalias; 1 commit adding/updating tests in test/script-cases/trace-analysis-listener-v1, test/script-cases/trace-analysis-v1-v2-checker; Add ActiveMQ monitoring E2E tests; Add e2e-protocol submodule for Java test service; Added GenAI e2e test infrastructure with mock LLM and Spring AI service; Added LAL v2 feature-case tests for execution, variable handling, and source attribution; Added Nacos MySQL schema initialization script for tests; Added OAP server testing module infrastructure; Added benchmark tests for EBPF profiling, OpenAPI endpoint grouping, and URI matching performance; 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 test SPI configuration for LAL V2 source type provider; Added test coverage for InstanceTraffic.combine timestamp logic; Added test coverage for runtime-rule DSL application and cluster routing; 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 Consul dynamic configuration; 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 GenAI evaluation record storage; Added tests for HTTP alarm callback timeout and 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 PagerDuty alarm hook callback; Added tests for ServerStatusService config dump masking and extension handling; Added tests for ServiceTraffic grouping logic; Added tests for StaticRuleRegistry; 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 Nacos configuration module; Added unit and integration tests for the Nacos cluster plugin; Added unit tests for Apdex, Percent, and HeatMap functions; 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 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 alarm hook callback; 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 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 unit tests for worker and stream processor behaviors; Added v2-only MAL DSL execution tests; Enable inline mocking for tests; Integration tests for Apollo dynamic configuration; New Java e2e-service-provider fixture for end-to-end testing; New e2e-mock-sender service for E2E testing infrastructure.

Dependencies

Introduce OAP Server BOM and modularize build artifacts

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

Stabilized build environment with Maven Wrapper 3.1.0 and Maven 3.8.4

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

Update protocol submodule to commit 07882d5

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 67 → 64 (-2.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 62 → 62 (+0.0)
  • Architecture 98 → 95 (-2.3)
  • Maturity 77 → 80 (+2.7)
  • Readiness 70 → 69 (-1.0)
  • Security 68 → 57 (-11.0)
  • Performance 72 → 95 (+23.1)

Resolved (95)

  • ADR has no Decision and Consequences section (docs/en/swip/SWIP-12.md)
  • ADR has no Decision and Consequences section (docs/en/swip/SWIP-13.md)
  • ADR has no Decision and Consequences section (docs/en/swip/SWIP-14.md)
  • AliasRegistrar.register (cognitive 17) (oap-server/analyzer/trace-analyzer/src/main/java/org/apache/skywalking/oap/trace/analyzer/v2/provider/span/AliasRegistrar.java)
  • AliasRegistrar.serviceNamedBy (cognitive 18) (oap-server/analyzer/trace-analyzer/src/main/java/org/apache/skywalking/oap/trace/analyzer/v2/provider/span/AliasRegistrar.java)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Documentation: no project overview (docs/en/FAQ/New-ElasticSearch-storage-option-explanation-in-9.2.0.md)
  • 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/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALClassGenerator.java)
  • Duplicated block (10 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (10 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (10 lines × 2) (oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/common/dao/JDBCEventQueryDAO.java)
  • Duplicated block (10 lines × 3) (oap-server/analyzer/trace-analyzer/src/main/java/org/apache/skywalking/oap/trace/analyzer/v2/compiler/TALBlockCodegen.java)
  • Duplicated block (11 lines × 2) (oap-server/analyzer/agent-analyzer/src/main/java/org/apache/skywalking/oap/server/analyzer/provider/trace/parser/listener/RPCTrafficSourceBuilder.java)
  • Duplicated block (12 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALDefCodegen.java)
  • Duplicated block (13 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALCodegenHelper.java)
  • Duplicated block (13 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALDefCodegen.java)
  • Duplicated block (13 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (13–15 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALClassGenerator.java)
  • Duplicated block (17 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALDefCodegen.java)
  • …and 75 more

New (633)

  • Banned license: org.openjdk.jmh:jmh-core
  • ClassTooLong: TALScriptModel (oap-server/analyzer/trace-analyzer/src/main/java/org/apache/skywalking/oap/trace/analyzer/v2/compiler/TALScriptModel.java)
  • CoreModuleProvider.prepare (cognitive 16) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/CoreModuleProvider.java)
  • Critical CVE: [GHSA redacted] (apm-protocol/apm-network/pom.xml)
  • Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
  • Duplicated block (10 lines × 2) (oap-server/server-receiver-plugin/skywalking-mesh-receiver-plugin/src/main/java/org/apache/skywalking/aop/server/receiver/mesh/TelemetryDataDispatcher.java)
  • Duplicated block (10 lines × 3) (oap-server/analyzer/trace-analyzer/src/main/java/org/apache/skywalking/oap/trace/analyzer/v2/compiler/TALBlockCodegen.java)
  • Duplicated block (10–11 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALCodegenHelper.java)
  • Duplicated block (16 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALScriptParser.java)
  • Duplicated block (17 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (20 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALDefCodegen.java)
  • Duplicated block (6 lines × 2) (oap-server/server-receiver-plugin/skywalking-mesh-receiver-plugin/src/main/java/org/apache/skywalking/aop/server/receiver/mesh/TelemetryDataDispatcher.java)
  • Duplicated block (7 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (7 lines × 2) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/otlp/OTLPServiceRelationTraffic.java)
  • Duplicated block (9 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALBlockCodegen.java)
  • Duplicated block (9 lines × 2) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALValueCodegen.java)
  • Duplicated block (9 lines × 2) (oap-server/server-alarm-plugin/src/main/java/org/apache/skywalking/oap/server/core/alarm/provider/grpc/GRPCCallback.java)
  • Edited copies of one member (3 members, 10+ corresponding lines) (oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/dsl/debug/LALDebug.java)
  • Edited copies of one member (3 members, 10+ corresponding lines) (oap-server/server-admin/dsl-debugging/src/main/java/org/apache/skywalking/oap/server/admin/dsl/debugging/cluster/DSLDebuggingClusterClient.java)
  • Edited copies of one member (3 members, 10+ corresponding lines) (oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/profiling/asyncprofiler/storage/AsyncProfilerTaskRecord.java)
  • …and 613 more

Changes since last survey

  • 28 commits — 17 feature/other, 11 fixes

By area

  • docs/en — 10 commits
  • test/e2e-v2 — 7 commits
  • oap-server/analyzer — 4 commits
  • oap-server/server-alarm-plugin — 2 commits
  • (root) — 1 commit
  • .github/workflows — 1 commit
  • oap-server/server-fetcher-plugin — 1 commit
  • oap-server/server-query-plugin — 1 commit
  • oap-server/server-storage-plugin — 1 commit

Notable commits

  • fix: Begin the 11.2.0 iteration and fix the release script on macOS (#14193)
  • fix: Bump dependencies to fix security alerts (#14191)
  • fix: Count gRPC alarm hook deliveries in the alarm delivery metrics and fix webhook hooks skipped next to other hook types (#14207)
  • fix: Fix Cilium flow streams stopped by a stale interrupt and isolate a malformed gRPC alarm hook (#14197)
  • fix: Fix Cilium node-list races, closed-node reuse and the gRPC alarm hook NPE (#14195)
  • fix: Fix Kafka broker throughput, topic metrics and idle percentage (#14167)
  • fix: Fix RabbitMQ publisher/multiblock unused and MySQL max_connections label (#14176)
  • fix: Fix RabbitMQ/PostgreSQL/Zabbix meter source miswires (#14171)
  • fix: Follow-ups to #14208: doc fixes, OTLP AI evaluation tests and e2e download hardening (#14209)
  • fix: Update the release guide for the redesigned website and fix the Zabbix doc links (#14202)
  • fix: [docs] Fix small text issues in README and CONTRIBUTING (#14185)
  • change: Accept the All wildcard on TraceQL status and kind, and document the OTLP Grafana dashboard (#14188)
  • change: Add HTTP alarm hook delivery so11y metrics on telemetry Prometheus (#14190)
  • change: Add server clusters to name a broker, database or cache as one service (#14183)
  • change: Add the OTLP_VIRTUAL_GATEWAY layer, and gateway practice notes from real runs (#14200)
  • change: Analyze OTLP spans opt-in by service.layer, and file the OTLP service catalog by layer (#14170)
  • change: Bump dependencies to clear the open Dependabot CVE alerts before the release (#14187)
  • change: Clarify the admin port's restriction and the config dump's secret masking in the docs (#14212)
  • change: Count a TAL consumer's receive span that has a parent as its request (#14179)
  • change: Document how a release is named in the release guide (#14196)
  • …and 8 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 3 added · 2 removed

Added dependency edges (3)

  • ai-evaluation → agent-analyzer
  • data-generator → trace-analyzer
  • trace-analyzer → agent-analyzer

Removed dependency edges (was a dependency, now gone) (2)

  • ai-evaluation → agent-analyzer (coupling)
  • data-generator → agent-analyzer

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 56fe1cdb8d3e34cdb6b499590b64d25fd8fa8816 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.