pinpoint-apm/pinpoint

This system is Pinpoint, a Java-based Application Performance Monitoring (APM) tool that provides distributed tracing and profiling for microservices. It operates via a Java agent that instruments a wide variety of frameworks, databases, and messaging systems to capture request flows, performance metrics, and exception traces. The backend components collect this telemetry data, storing it in HBase and Pinot to power application maps, real-time statistics, and alarm notifications.

195 changes.

The project underwent a comprehensive architectural shift, migrating core modules like the collector, web, and batch systems to Spring Boot with Java-based configuration while introducing new modules for Pinot integration, Redis-based real-time communication, and log streaming. Simultaneously, the agent module expanded significantly with dozens of new plugins for modern frameworks and databases, alongside major updates to support Jakarta EE, Spring Framework 7, and Java 9+ module systems.

31 changes.

This period focused on expanding distributed tracing capabilities by introducing new plugins for Apache Pulsar, AWS S3, Jetty 12, and Oracle JDBC, alongside significant infrastructure updates like a standalone OTLP trace collector and a new timeseries commons library. The work also included migrating the user module to Jakarta EE, refactoring application map data access for V3 storage, and establishing a dedicated batch module for alarm evaluation. Extensive integration testing was added to validate these new features and ensure compatibility with modern frameworks like Spring Boot 4 and Spring Framework 7.

Introduces a new profiler plugin for the AWS SDK for Java v2 S3 client, enabling distributed tracing of S3 operations. The plugin instruments the S3 client, HTTP response handlers, and XML protocol marshalling to record service type, HTTP URLs, and internal display attributes (such as status codes and ETags). It supports configuration via \profiler.aws.sdk.s3.enable\, \profiler.aws.sdk.s3.statuscode\, and \profiler.aws.sdk.s3.mark.error\ to control tracing activation, status code recording, and error marking.

agent-module/plugins/aws-sdk-s3 · high confidence

This change introduces a new profiler plugin for Apache CXF (versions 3.0 to 3.5), enabling automatic tracing of CXF-based web services and REST clients. The plugin supports service profiling (intercepting \ServiceInvokerInterceptor\ and \MessageSenderInterceptor\), logging profiling (intercepting \LoggingInInterceptor\ and \LoggingOutInterceptor\ to capture request/response details like address, HTTP method, and payload), and client profiling (intercepting \ClientProxy\ and \MessageSenderEndingInterceptor\). Configuration is controlled via \pinpoint.config\ properties such as \profiler.cxf.service.enable\, \profiler.cxf.logging.enable\, and the deprecated \profiler.cxf.client\. The plugin registers new service types (e.g., \CXF\_SERVICE\_INVOKER\, \CXF\_LOGGING\_IN\) and annotation keys for detailed trace records.

agent-module/plugins/hbase · high confidence

Introduces a new profiling plugin for Apache Pekko HTTP (formerly Akka HTTP), enabling distributed tracing for HTTP server requests. The plugin instruments request handling to capture HTTP method, URI path, and remote IP address (configurable via the real IP header setting), while supporting URL and HTTP method exclusions. It records HTTP status codes and exceptions for completed requests, ensuring visibility into request lifecycle and errors within Pekko HTTP-based applications.

agent-module/plugins/akka-http · high confidence

This release introduces a new profiler plugin for Apache Pulsar (client range 4.0.0+), enabling distributed tracing for both producers and consumers. Users can enable producer instrumentation via \profiler.pulsar.producer.enable\ and consumer instrumentation via \profiler.pulsar.consumer.enable\ in \pinpoint.config\. The plugin instruments \ProducerImpl\ and \ConsumerImpl\ to record trace spans, propagate context headers, and capture attributes such as topic, partition, message ID, and broker URL.

agent-module/plugins/pulsar · high confidence

Pinpoint now profiles CUBRID database connections, allowing users to trace CUBRID SQL execution, connection lifecycle, and transaction details (commit, rollback, setAutoCommit) via the new cubrid-jdbc plugin. Configuration is controlled by the \profiler.jdbc.cubrid\ flags in pinpoint.config, and the plugin supports CUBRID JDBC driver versions 8.2.0 through 11.1.1.

agent-module/plugins/cubrid-jdbc · high confidence

Introduces a new profiler plugin for the DataStax Java Driver Core version 4.x (range 4.1.0 to 4.15). This plugin enables automatic tracing of Cassandra CQL operations, including session initialization, statement execution, and connection closure. It supports recording SQL bind values for SimpleStatement, PreparedStatement, and BoundStatement, and captures database metadata such as host lists and keyspace information for improved trace visibility.

agent-module/plugins/cassandra4 · high confidence

Introduces a new profiler plugin for the DataStax Java Cassandra driver (versions 2.0 to 3.11), enabling automatic tracing of Cassandra CQL operations. The plugin instruments connection creation, statement preparation, and query execution to capture database info, SQL parsing results, and bind values. Users can enable it via the \profiler.cassandra=true\ configuration flag and optionally enable bind value tracing with \profiler.cassandra.tracecqlbindvalue=true\.

agent-module/plugins/cassandra · high confidence

Introduces a new plugin for the Dameng (DM8) JDBC driver, enabling Pinpoint to profile connections, statements, and transactions for this database. The plugin includes configuration options in pinpoint.config (e.g., \profiler.jdbc.dameng=true\) to enable profiling and control tracing of autocommit, commit, and rollback operations, as well as SQL bind values. It provides a custom URL parser to extract host, port, and group information from \jdbc:dm://\ connection strings and registers the necessary service types for trace metadata.

agent-module/plugins/dameng-jdbc · high confidence

A new test web module has been added to support testing the Db2 JDBC plugin. This includes a Spring Boot application with REST endpoints for executing standard queries, prepared statements, and callable procedures against a Db2 database, along with the necessary database initialization scripts and test infrastructure using Testcontainers.

agent-module/agent-testweb/db2-jdbc-plugin-testweb · high confidence

Introduces a new profiling plugin for the Elasticsearch 8.x Java client (co.elastic.clients/elasticsearch-java \[8.0, 8.5\]), enabling distributed tracing for synchronous and asynchronous client operations. The plugin instruments \ElasticsearchClient\ and \ElasticsearchAsyncClient\ to record span events for methods such as index, get, search, delete, and update, capturing endpoint details, DSL query snippets, and cluster version information via configurable options.

agent-module/plugins/elasticsearch, agent-module/plugins/elasticsearch8 · high confidence

This change introduces a new profiler plugin for the Alibaba Fastjson library (versions 1.2 to 2.0), enabling automatic tracing of JSON parsing and serialization operations. The plugin instruments key methods including parse, parseObject, parseArray, toJSON, toJavaObject, toJSONString, toJSONBytes, and writeJSONString. When enabled via the \profiler.json.fastjson\ configuration flag, it records span events with the FASTJSON service type and annotates them with the length of the JSON payload (or hash code for object results), providing visibility into JSON processing performance and data sizes within distributed traces.

agent-module/plugins/fastjson · high confidence

This change introduces a new profiler plugin for Jetty 12, enabling distributed tracing for applications running on Java EE 10 and EE 11 servlet specifications. The plugin automatically detects Jetty 12 instances and instruments the \ServletHandler.handle\ entry point to capture request and response data, while also supporting asynchronous request tracing via \AsyncContext\. Traces are rendered under the existing JETTY application type to maintain consistency with legacy Jetty versions.

agent-module/plugins/jetty12 · high confidence

This change introduces a new Pinpoint agent plugin for the Ktor framework (versions 2.3 through 3.5), enabling automatic distributed tracing for both server-side requests and client-side outbound HTTP calls. For servers, the plugin instruments Netty HTTP handlers and suspend functions to capture request traces, supporting configuration for URL exclusions, real IP headers, and routing retransformation. For clients, it instruments \HttpSend$DefaultSender.execute\ to record outbound span events per HTTP attempt (including retries), with specific handling for Kotlin coroutines to ensure completion spans are recorded on the correct resume trace rather than creating orphaned async traces. Users can enable or disable the plugin and its client/server components via \profiler.ktor.enable\ and \profiler.ktor.client.enable\ in \pinpoint.config\.

agent-module/plugins/ktor · high confidence

New sample applications have been added for Micronaut and Quarkus that instrument HTTP server and client spans using the OpenTelemetry SDK directly, exporting traces to Pinpoint via OTLP without requiring the Pinpoint Java Agent or OpenTelemetry Java Agent. These testwebs allow users to verify that standard OTel instrumentation and W3C trace context propagation work correctly with Pinpoint's collector.

agent-module/agent-testweb/micronaut-opentelemetry-testweb, agent-module/agent-testweb/quarkus-opentelemetry-testweb · high confidence

Introduces a new profiling plugin for Apache OpenWhisk that automatically detects whether the application is a Controller or Invoker and instruments key lifecycle methods to capture distributed traces. The plugin records transaction start, finish, and failure events, propagates trace context across Kafka producer sends, and supports optional logging of marker messages for deeper visibility into serverless function execution.

agent-module/plugins/openwhisk · high confidence

Introduces a new profiler plugin that enables distributed tracing for applications using Spring Cloud Sleuth with Project Reactor. The plugin instruments the \reactor.core.CoreSubscriber\ interface to capture trace context across asynchronous reactive streams, registering a new service type (SPRING\_CLOUD\_SLEUTH) for visualization. Users can enable this capability via the \profiler.spring.cloud.sleuth.enable\ configuration flag.

agent-module/plugins/spring-cloud-sleuth · high confidence

This change introduces a new profiler plugin for the Undertow Servlet container (versions 2.0.0.Final to 2.0.16.Final), enabling distributed tracing for asynchronous servlet requests. The plugin instruments \HttpServletRequestImpl.startAsync\ to capture the start of async operations and registers an \UndertowAsyncListener\ to track completion, timeout, and error events, ensuring that async spans are properly closed and recorded in the trace. This is particularly useful for environments like WildFly where the Servlet library ClassLoader is separated.

agent-module/plugins/undertow-servlet · high confidence

Introduces a new profiler plugin for Oracle WebLogic (versions 10–12) that automatically detects the application server via the bootstrap main class and instruments servlet requests to capture RPC traces, HTTP method, endpoint, and query parameters. The plugin supports Servlet 3.0 asynchronous request tracing, configurable URL and HTTP-method exclusion filters, request parameter tracing, real-IP header resolution, and optional hiding of Pinpoint headers, with setup instructions provided in the new README.

agent-module/plugins/weblogic · high confidence

This change introduces a new plugin for the jTDS JDBC driver (versions 1.2 to 1.3), enabling Pinpoint to profile SQL Server connections made via jTDS. The plugin parses jTDS-specific JDBC URLs to extract host, port, and database information, and instruments key database operations including connection creation, statement execution, and transaction management (commit, rollback, setAutoCommit). Users can enable this profiling by setting \profiler.jdbc.jtds=true\ in their \pinpoint.config\.

agent-module/plugins/jtds · high confidence

The agent now includes new plugins for profiling Informix and Microsoft SQL Server databases. For Informix, the plugin supports JDBC driver versions 4.10 through 4.50, enabling tracing of connections, statements, prepared statements, and transactions, with configuration options in pinpoint.config to control profiling of setAutoCommit, commit, and rollback operations. For Microsoft SQL Server, the plugin supports driver versions 6.1 through 12.1, providing similar tracing capabilities for connections, statements, and transactions, also configurable via pinpoint.config. Both plugins register their respective JDBC URL parsers and service types to ensure accurate database identification and trace recording.

(repo-wide) · high confidence

This change introduces the web-facing components for the new OTLP metric feature. It adds a Spring configuration module that enables the feature via the \pinpoint.modules.web.otlpmetric.enabled\ property and wires up MyBatis data access for both MySQL (storing user-defined metric definitions) and Pinot (querying metric data). New REST controllers expose endpoints for managing metric definitions (\/api/otlp/metricDef/\*\) and querying metric data (\/api/otlp/metricData\), while legacy endpoints for metric groups and charts are marked as deprecated. Configuration properties for query periods and intervals are also added and exported to the frontend.

otlpmetric/otlpmetric-web · high confidence

This update introduces the \profiler-optional-jdk8\ module, providing specific profiler capabilities for JDK 8 environments, with a focus on IBM Java compatibility and lambda support. It adds IBM-specific metric implementations for CPU load and file descriptors, alongside Oracle equivalents, to ensure accurate system monitoring across different JVM vendors. The module also includes a new bytecode instrumentation engine (\LambdaFactoryClassAdaptor\ and \MethodInstReplacer\) to handle lambda factory transformations, and a specialized shutdown hook register (\Java7ShutdownHookRegister\) to manage agent lifecycle on older Java versions. Comprehensive tests are included to verify lambda transformation and interface interception logic.

agent-module/profiler-optional/profiler-optional-jdk8 · high confidence

This change introduces a new MapStruct Service Provider Interface (SPI) implementation to correctly handle Google Protobuf message types during code generation. It registers a custom \ProtobufAccessorNamingStrategy\ that filters out internal Protobuf methods (such as \newBuilder\, \clear\, and \getOneOf...Case\) to prevent unmapped target warnings and ensure accurate property mapping. Additionally, a \ProcessingEnvOptionsHolder\ processor is added to expose MapStruct compiler options (like \mapstructSpi.enumPostfixOverrides\) to the custom strategy, resolving previous warnings caused by unmapped targets in Protobuf-generated classes.

commons-mapstruct-spi · high confidence

A new test web application has been added to support testing of the Pulsar plugin. This includes a Spring Boot starter, a controller that initializes a Pulsar consumer and provides an endpoint to send messages to a 'pinpoint-test' topic, and configuration for the application to run on port 9000.

agent-module/agent-testweb/pulsar-plugin-testweb · high confidence

The annotations module now includes \InterfaceAudience\ and \InterfaceStability\ annotations (adapted from Hadoop) to classify public, limited-private, and private interfaces, as well as their stability levels (Stable, Evolving, Unstable). Additionally, a \VisibleForTesting\ annotation (adapted from Guava) is provided to mark elements intended only for test code. All new annotations use \RetentionPolicy.RUNTIME\ to ensure they are available at runtime.

annotations · high confidence

The agent now includes new plugins for Apache Commons DBCP (versions 1.0–1.4) and DBCP2 (versions 2.0–2.9), enabling detailed tracing of database connection lifecycle events. These plugins instrument \BasicDataSource\ and \PoolingDataSource\ classes to record spans for connection acquisition (\getConnection\) and closure, while also monitoring pool health metrics such as active and maximum connection counts. Users can enable this functionality via the \profiler.jdbc.dbcp\ and \profiler.jdbc.dbcp2\ configuration flags, with an optional \connectionclose\ setting to specifically profile connection close events.

(repo-wide) · high confidence

This change introduces a comprehensive set of README files and configuration assets for the agent-module, providing users with clear instructions for running the various agent testwebs (covering plugins like Jetty 12, DB2, Micronaut, Quarkus, and Spring Boot 3/4) and understanding the agent plugins' supported library versions. It also adds Docker build files and a configure-agent script to streamline containerized agent deployment, along with an assembly descriptor for packaging agent plugins.

agent-module · high confidence

The plugin test module now registers the custom PluginTestEngine and PluginPostDiscoveryFilter via JUnit Platform service files, enabling the framework to discover and execute plugin-specific tests. Additionally, test logging is configured via tinylog to output to the console at the INFO level with a structured format, ensuring consistent visibility of test execution details.

agent-module/plugins-test-module/plugins-test/src/main/resources · high confidence

The agent-statistics-collector module now supports writing agent information to Pinot by introducing a new Spring configuration that activates when the property pinpoint.modules.collector.agent-statistics.enabled is set to true. This change adds a Kafka producer pipeline (using the agent-info topic) to transmit AgentInfoEntity data, which is mapped from internal business objects and includes a new serviceInfosString field to support text matching in Pinot.

agent-statistics/agent-statistics-collector · high confidence

The repository is initialized with essential project documentation and configuration files. This includes a comprehensive README.md detailing the Pinpoint APM architecture, supported modules (JDK, application servers, databases, etc.), and compatibility tables for Java, HBase, Pinot, and agent-collector versions. Supporting documentation files such as CONTRIBUTING.md, BUILD.md, and AGENTS.md (for AI coding agents) are added. Standard project files like LICENSE, NOTICE, and .gitignore are established, along with the Maven Wrapper (mvnw) to ensure consistent build environments.

(repo-wide) · high confidence

Adds a new HBase schema manager component that provides CLI commands (init, update, reset, summary, log) to manage HBase schema changes. The tool supports dry-run mode to preview changes without applying them, allows configuration of the target namespace and compression algorithm, and exposes HBase connection settings (host, port, znode parent) via command-line arguments or properties.

hbase/hbase-schema-manager · high confidence

This change introduces the pinot-datasource module, providing a new PinotDataSource implementation and associated JDBC wrappers (WrappedPinotConnection, WrappedPinotPreparedStatement) to facilitate database interactions. It adds a PinotAsyncTemplate that enables asynchronous query execution via CompletableFuture, allowing users to perform non-blocking data retrieval. The module also includes a SimpleTenantProvider for tenant management and utility classes for parameter recording and JDBC resource handling.

pinot/pinot-datasource · high confidence

The collector module has been migrated to a Spring Boot architecture, replacing the legacy XML-based configuration with Java-based modules (PinpointCollectorModule, CollectorHbaseModule, etc.) and introducing a new entry point (CollectorApp). This change includes the implementation of ServerMap V3, which updates the application map data handling to use new DAOs and bulk writers for link and agent statistics, and adds support for dual-write scenarios via a HostApplicationMapDaoDelegate. The collector now exposes gRPC ports 9991-9993 for agent, span, and stat data respectively, and uses a new property source structure for configuration.

collector · high confidence

The otlpmetric-common module now provides a shared set of model and view classes to support OpenTelemetry metric definitions and data exchange. This includes enums for metric types (Gauge, Sum, Histogram, etc.), aggregation functions (Average, Sum, Min, Max, Latest), and chart types (Line, Area, Bar), alongside data structures for metric definitions (AppMetricDefinition) that support field-tag relationships, stacking, and layout. View objects (MetricDataView, MetricValueView) are introduced to serialize metric data for API responses, and utility classes (TimeSeriesBuilder, MetricPoints) assist in time-series point handling.

otlpmetric/otlpmetric-common · high confidence

A new \commons-config\ module has been added to provide a lightweight, Spring-inspired configuration system. It introduces a \@Value\ annotation that allows fields and setter methods to be automatically populated with values from a property source (such as a \Properties\ object). The module includes a \ValueAnnotationProcessor\ that resolves placeholders (e.g., \${key}\) and supports default values (e.g., \${key:-default}\), handling type conversion for primitives, wrappers, strings, and enums. This enables components to declare their configuration dependencies declaratively rather than through manual lookup logic.

commons-config · high confidence

This change adds the core data structures and storage definitions for the new exception trace feature. It introduces the \ExceptionMetaData\ and \StackTraceElementWrapper\ Java models, which capture exception details including a new \tenantId\ for multi-tenancy, \serviceName\, and CLP-encoded error messages. It also defines the Pinot table schemas and configurations for both real-time and offline ingestion of exception trace data, including specific column indexing and retention policies.

exceptiontrace/exceptiontrace-common · high confidence

This change introduces a new gRPC-based transport module for Pinpoint, replacing or supplementing previous communication mechanisms. It adds support for the V4 protocol version, which enforces the \servicetype\ header as required and introduces optional \servicename\ and \apikey\ headers. The module includes a new \ChannelFactory\ with builder support for configuring interceptors, SSL contexts, and retry options, and allows selection between NIO and Epoll channel types. Additionally, it provides utilities for channel management, logging, and Channelz monitoring.

grpc · high confidence

Adds the \inspector-web\ module, providing REST API endpoints under \/api/inspector/agentStat\ and \/api/inspector/applicationStat\ to retrieve agent and application performance charts. The implementation uses Spring configuration to wire MyBatis mappers against a Pinot data source, enabling asynchronous queries for metrics like Apdex and general agent stats, with access controlled via \@PreAuthorize\ annotations.

inspector-module/inspector-web · high confidence

This change adds the core implementation for the new plugin test engine, including the AbstractPluginTestSuite and AbstractPluginForkedTestSuite base classes, their Default implementations, and supporting components like ClassLoading, ConfigResolver, and ProcessManager. Users will now benefit from a refactored test execution model that supports forked test suites, shared dependency resolution via Maven, and improved class loading isolation for plugin integration tests.

agent-module/plugins-test-module/plugins-test/src/main/java · high confidence

The metric-module/metric location now includes a new system metric collector implementation that receives Telegraf metrics via a REST API, validates host names, and persists data using Pinot-backed DAOs. The collector uses Caffeine caches for metric tags and data types, sends metric data to Kafka topics (including tenantId), and is enabled via the pinpoint.modules.collector.systemmetric.enabled property rather than a Spring profile.

metric-module/metric · high confidence

This change adds the \commons-timeseries\ module, providing foundational classes for time-series data handling. It introduces value types like \DoubleDataPoint\ and \LongDataPoint\ to represent timestamped metrics, along with utility classes for array conversions (\DoubleArray\, \IntArray\, \LongArray\). The module also includes time management utilities such as \Timestamp\ (supporting ISO 8601 and epoch formats), \Range\ for time intervals, and \TimeWindow\ for aggregating data into time-based buckets. Additionally, it provides helper classes for time precision, range splitting, and timestamp inversion.

commons-timeseries · high confidence

The feature-flag module now supports a simple property-based feature flag system, allowing administrators to define feature flags via the \features\ configuration prefix. Flags can be toggled globally or scoped to specific applications using \enabledFor\ and \disabledFor\ lists, with disabled lists taking precedence. This change also updates the underlying \FeatureFlagProperties\ structure from a Map to a List to support these per-application rules, and includes a factory to resolve the correct service implementation based on these properties.

feature-flag · high confidence

A new basic-login module has been added to Pinpoint, allowing users to enable simple username/password authentication via the \pinpoint.modules.web.login=basicLogin\ property. This module issues a \pinpointJwt\ cookie for session management, which defaults to \HttpOnly\ enabled and \Secure\ disabled (requiring explicit configuration for HTTPS environments), with a \SameSite\ attribute of \Lax\. The implementation enforces a mandatory, non-default JWT secret key (\web.security.auth.jwt.secretkey\) to prevent the use of the previously shipped, publicly known example value, and configures Spring Security to use stateless sessions with BCrypt password encoding.

basic-login · high confidence

A new standalone OTLP trace collector application has been added to ingest OpenTelemetry trace data via gRPC (default port 9998) and HTTP (POST /v1/traces). The HTTP endpoint now accepts both protobuf and JSON payloads, with a custom parser handling OTLP's hex-encoded ID fields. To protect the service, an admission control filter enforces limits on request size (4 MB default), in-flight bytes (256 MB default), and concurrent requests (64 default), while a decompression filter handles gzip bodies. The collector is gated by the \pinpoint.modules.collector.otlptrace.enabled\ configuration flag and includes optional TLS support on a separate port (9448).

otlptrace/otlptrace-collector · high confidence

The web-starter module now provides a new \PinpointWebStarter\ entry point that bundles core web components (Metric, UriStat, Inspector, Log, ExceptionTrace, and OpenTelemetry metrics) and configures Spring Boot Actuator endpoints under the \/monitor\ base path. This starter enables server-side gzip compression for \application/json\, exposes Tomcat metrics via MBean registry, and activates all web modules (including heatmap and service map) by default. It also introduces WebSocket configuration options for session timeouts and message buffer sizes.

web-starter · high confidence

This change adds the foundational value objects and protocol configuration required for the new log livetail capability. It introduces domain models including FileKey, HostKey, Log, LogPile, LogFileList, LogDemand, and LogSupply to structure log data and requests. Additionally, it provides LogServiceProtocolConfig, which wires these models into the channel service infrastructure using Redis PubSub and Redis Stream, establishing the communication backbone for real-time log delivery.

log/log-common · high confidence

The commons module has been introduced, providing foundational components for the Pinpoint tracing system. This includes the \PinpointConstants\ class defining identifiers like \AGENT\_ID\_MAX\_LEN\ and \AGENT\_NAME\_MAX\_LEN\, a version management system via \VersionTemplate\ and \Version\, and a generic caching layer with \Cache\ and \LRUCache\ implementations. The module also establishes the core tracing data model with \AnnotationKey\ and \ServiceType\ interfaces, their respective factory and builder classes (\AnnotationKeyBuilder\, \DefaultServiceType\), and utility classes like \HostAndPort\. Additionally, it introduces error categorization logic through \ErrorCategory\ and \ErrorCategoryResolver\, and histogram schema definitions via \BaseHistogramSchema\ to support performance metric collection.

commons · high confidence

The bootstrap module now includes a new Java 9+ classloader and module support layer to handle Java Platform Module System (JPMS) constraints. This adds a custom classloader that respects module boundaries, a module factory and wrapper to interact with Java 9+ module APIs, and utilities to analyze JAR files for packages and service providers. It also includes logic to dynamically redefine modules at runtime to grant the agent necessary permissions (exports, opens, reads) to instrument target applications, ensuring compatibility with modular Java environments.

agent-module/bootstraps/bootstrap-java9 · high confidence

The commons-mybatis module now provides a new Spring-based configuration that sets default MyBatis settings (such as lazy loading, underscore-to-camel-case mapping, and a 5-second statement timeout) and registers a new BindingLogPlugin. This plugin intercepts MyBatis executor methods to log the final SQL query with bound parameters, supporting customizable formatting and whitespace removal via the new BindLogFormatter interface and DefaultBindingLogFormatter implementation.

commons-mybatis · high confidence

The agent now includes a new plugin for tracing Apache ActiveMQ client interactions (versions 5.1.0 to 5.16). This plugin instruments message producers and consumers to propagate distributed trace context via custom JMS headers (e.g., Pinpoint-TraceID, Pinpoint-SpanID). Users can enable or disable tracing for producers and consumers independently, configure the destination path separator, and exclude specific destinations from tracing via the \pinpoint.config\ file.

agent-module/plugins/activemq-client, agent-module/plugins/apache-dubbo, agent-module/plugins/rocketmq · high confidence

A new plugin has been added to automatically trace asynchronous tasks executed via the Pinpoint Agent SDK. It instruments SDK classes such as TraceRunnable, TraceCallable, and various TraceExecutor services to capture execution spans and propagate async context, allowing distributed traces to correctly link synchronous entry points with their asynchronous background work.

agent-module/plugins/agentsdk-async · high confidence

This change introduces a new plugin that enables distributed tracing for applications using Apache HttpClient 4.x (versions 4.0 through 4.5). The plugin instruments the client to capture HTTP call details, including request/response headers, cookies, and POST/PUT entity bodies, with configurable sampling and dumping options. It supports both synchronous and asynchronous HTTP clients, recording execution times, status codes, and I/O metrics to help users monitor and debug external HTTP dependencies.

agent-module/plugins/httpclient4 · high confidence

This release introduces a new plugin that enables distributed tracing for applications using Apache HttpClient 5.x (versions 5.0 through 5.2). The plugin instruments both synchronous and asynchronous HTTP client operations, capturing request details such as URLs, headers, cookies, and entity data. It supports configuration options to control the recording of parameters, cookies, and entity dumps, as well as error marking and status code recording. Users can enable this feature by setting \profiler.apache.httpclient5.enable=true\ in their configuration.

agent-module/plugins/httpclient5 · high confidence

This change introduces a new profiling plugin for the Arcus and Memcached caching systems. It instruments the \net.spy.memcached\ client library to capture distributed traces, recording service types for ARCUS, MEMCACHED, and their asynchronous future operations. The plugin supports configuration via \profiler.arcus\ and \profiler.memcached\ flags, enabling key tracing and async context propagation to visualize cache interactions and endpoints in the Pinpoint topology.

agent-module/plugins/arcus · high confidence

This change introduces a new profiling plugin for the AsyncHttpClient library (supporting both the legacy com.ning version 1.7–1.9 and the modern org.asynchttpclient version 2.0–2.12). The plugin instruments HTTP requests to capture distributed traces, recording details such as the destination host, URL, cookies, and request entities based on configurable sampling and dump settings. It also handles async context propagation and error marking, allowing users to monitor asynchronous HTTP calls within their applications.

agent-module/plugins/ning-asynchttpclient · high confidence

The agent now includes a dedicated plugin for ClickHouse, enabling automatic tracing of JDBC connections, statements, and prepared statements. This update adds support for the ClickHouse JDBC driver versions 0.3.2 and 0.8.0, allowing users to monitor database performance and trace transactions involving ClickHouse databases.

agent-module/plugins/clickhouse-jdbc · high confidence

This change introduces the \exceptiontrace-web\ module, providing the web-layer components to query and display exception trace data from Pinot. It includes a Spring configuration (\ExceptionTraceWebConfig\) that enables the feature via \pinpoint.modules.web.exceptiontrace.enabled\, a REST controller (\ExceptionTraceController\) exposing endpoints under \/api/errors\ (such as \/errorList\ and \/chart\) with \@PreAuthorize\ permission checks, and a MyBatis-based data access layer (\PinotExceptionTraceDao\) that maps query results to domain entities and views. The module also adds configuration properties for the maximum query period and interval, and a CLP (Columnar Log Pattern) mapper to decode encoded error messages.

exceptiontrace/exceptiontrace-web · high confidence

A new \hbase-schema\ module has been added to manage HBase table definitions and schema migrations. This includes core components for tracking schema change logs (\SchemaChangeLogDao\, \ChangeSetManager\), verifying schema integrity (\HbaseSchemaVerifier\), and executing schema updates via command objects (\CreateTableCommand\, \ModifyTableCommand\). The module provides the infrastructure to read, validate, and apply HBase schema changes, ensuring tables are created or modified according to defined change sets.

hbase/hbase-schema · high confidence

This change introduces a new plugin for the Pinpoint Java agent to provide automatic instrumentation and tracing for JBoss Web Server (versions 6 and 7). The plugin detects the JBoss application server type and, depending on configuration, instruments EJB method invocations for remote EJB-based applications or standard Servlet 3.0 asynchronous requests for REST-based applications. It also supports hiding Pinpoint-specific headers from external responses and allows for custom configuration of excluded URLs, request parameters, and real IP address headers via the agent's configuration file.

agent-module/plugins/jboss · high confidence

The \plugins-it-utils-jdbc\ module has been added to provide a shared set of utilities for JDBC plugin integration tests. This includes a \DataBaseTestCase\ base class for setting up database connections and verifying trace data, a \SimpleJdbcTemplate\ for executing SQL statements, and helper classes for managing driver registration and transaction handling. The module also introduces \DatabaseContainers\ to simplify the configuration of test databases using Testcontainers.

agent-module/plugins-test-module/plugins-it-utils-jdbc · high confidence

A new test web application has been added to the agent-testweb module to facilitate testing of the JDK HTTP plugin. This service runs on both HTTP (port 18080) and HTTPS (port 18443) with HTTP/2 enabled, loading a custom SSL keystore for secure connections. It exposes endpoints for making HTTP/HTTPS GET and POST requests, inspecting request and response headers, and simulating connection errors, providing a dedicated environment for validating agent behavior against standard JDK HTTP client implementations.

agent-module/agent-testweb/jdk-http-plugin-testweb · high confidence

The agent now includes a new profiler plugin for the standard JDK \HttpURLConnection\ (including HTTPS), enabling distributed tracing for Java applications using this client. This plugin instruments connection methods to capture request details, response headers, and status codes, while also preventing nested tracing loops to ensure accurate span data. Users can enable the feature via the \profiler.jdk.http\ configuration flag.

agent-module/plugins/jdk-http · high confidence

A new Jetty profiler plugin has been added to the agent, enabling distributed tracing for applications running on Jetty versions 8.0 through 11.x. The plugin automatically detects the Jetty version and applies the appropriate bytecode instrumentation to capture request and response data. It supports both the legacy javax.servlet API (for Jetty 8–9) and the Jakarta EE API (for Jetty 10–11), ensuring compatibility across major platform updates. Users can configure the plugin via pinpoint.config to enable/disable tracing, exclude specific URLs or HTTP methods, hide Pinpoint headers, and control the recording of request parameters and real IP addresses.

agent-module/plugins/jetty · high confidence

This release introduces a new profiler plugin for tracing Kotlin Coroutines (org.jetbrains.kotlinx/kotlinx-coroutines-core). The plugin instruments key coroutine lifecycle methods—including dispatch, resume, cancellation, and construction—to capture async context propagation and span events. Users can enable tracing via the \profiler.kotlin.coroutines.enable\ configuration flag, and optionally enable \profiler.kotlin.coroutines.record.threadName\ and \profiler.kotlin.coroutines.record.cancel\ to record thread names and cancellation events for better debugging of coroutine behavior.

agent-module/plugins/kotlin-coroutines · high confidence

This change introduces new profiler plugins for Log4j (versions 1.1–1.2) and Logback (versions 1.0–1.4) that automatically inject Pinpoint transaction and span IDs into application logs. The plugins intercept logging event constructors to populate the MDC context and can optionally rewrite log patterns (e.g., replacing %m with TxId:%X{PtxId} %m) via configurable properties like profiler.log4j.logging.pattern.replace.enable. These plugins are disabled by default and must be explicitly enabled in pinpoint.config to take effect.

agent-module/plugins/log4j, agent-module/plugins/logback · high confidence

This change introduces a new Log4j2 profiler plugin that automatically injects Pinpoint transaction and span IDs into Log4j2's ThreadContext (MDC) for all logging events, ensuring traceability in application logs. It also supports an optional feature to automatically replace configured log message patterns (e.g., %message) with a version that includes the transaction ID, allowing for seamless integration of tracing information into existing log formats without manual code changes.

agent-module/plugins/log4j2 · high confidence

A new test web application has been added to validate the MySQL JDBC plugin. It includes a Spring Boot controller that exercises standard JDBC operations (insert, select, delete), stored procedures with IN/OUT and INOUT parameters, and the MySQL X DevAPI. The test environment is configured to run against a MySQL 8.0.36 instance via Testcontainers, using the mysql-connector-j driver.

agent-module/agent-testweb/mariadb-jdbc-plugin-testweb, agent-module/agent-testweb/mysql-jdbc-plugin-testweb · high confidence

The collector now includes a new \otlpmetric-collector\ module that enables ingestion of OpenTelemetry Protocol (OTLP) metrics via a new \/opentelemetry\ REST endpoint accepting protobuf payloads. The module handles the full pipeline: it parses OTLP metric types (Gauge, Sum, Histogram, ExponentialHistogram, Summary) into internal data models, extracts resource and scope attributes as tags, and routes the data to Pinot via Kafka templates (separate topics for metadata, long, and double data). Configuration is controlled by the \pinpoint.modules.collector.otlpmetric.enabled\ property and associated Kafka topic settings.

otlpmetric/otlpmetric-collector · high confidence

A new pinot-kafka module has been added to centralize the configuration of the Kafka producer used for sending metric data to Pinot. This change introduces a Spring-based configuration (KafkaConfiguration) that binds specific properties such as bootstrap servers, serializers, acks, compression type, and max block time. Notably, it makes the buffer memory and linger time configurable via the pinpoint.metric.kafka.buffer.memory and pinpoint.metric.kafka.linger.ms properties, allowing users to tune producer batching and memory usage. The module also includes a utility for logging send callbacks and provides profile-specific property files for local and release environments.

pinot/pinot-kafka · high confidence

The pinot-config module now provides the Spring configuration infrastructure for the Pinot integration. It introduces a dedicated datasource configuration that loads JDBC connection details (URL, username, password) and Pinot broker addresses from profile-specific property files (e.g., pinot-jdbc.properties for local and release environments). Additionally, it configures a TenantProvider using a configurable tenant ID (defaulting to 'pinpoint') loaded from pinot-tenant.properties, and applies specific MyBatis optimizations such as enabling caching and lazy loading. This change centralizes the wiring of these components, separating them from the main application context.

pinot/pinot-config · high confidence

This release introduces a new plugin for the Reactor Netty framework (versions 0.8.0.RELEASE to 0.9.2.RELEASE), enabling distributed tracing for both HTTP servers and HTTP clients. The plugin instruments key classes such as \HttpServerHandle\, \ChannelOperations\, and \HttpClientConnect\ to capture request and response details, including HTTP status codes, headers, and remote host information. It supports configuration for enabling/disabling server and client tracing, excluding specific URLs or methods, and handling real IP headers. The implementation also includes logic to manage async contexts and record transport or HTTP errors based on configuration flags.

agent-module/plugins/reactor-netty · high confidence

This change introduces a new profiler plugin for the Jedis Redis client (versions 2.4.x to 2.9.0). It instruments Jedis constructors to capture and record the Redis server endpoint (host and port) in traces. Additionally, it intercepts command execution to record read/write elapsed times and failure status, providing detailed I/O performance metrics for Redis operations.

agent-module/plugins/redis · high confidence

This change introduces a new profiler plugin for the Redis Lettuce client (versions 5.0.0.RELEASE to 5.1.2.RELEASE), enabling automatic distributed tracing for Redis operations. The plugin instruments \RedisClient\ and \RedisClusterClient\ constructors to capture endpoint information, and intercepts stateful connection and command methods to record span events, API details, and destination IDs. It supports both standard async commands and reactive publishers (Mono/Flux), with a configuration option (\profiler.redis.lettuce.wrap.publisher\) to switch between direct injection and wrapping of reactive publishers. Additionally, it provides optional tracing for Pub/Sub listeners, creating standalone traces for incoming messages when enabled.

agent-module/plugins/redis-lettuce · high confidence

The realtime-common module now provides Spring configuration classes (ATCServiceProtocolConfig, ATDServiceProtocolConfig, EchoServiceProtocolConfig) that wire the new channel framework for Active Thread Count, Active Thread Dump, and Echo operations. These configurations define the demand/supply DTOs (ATCDemand, ATCSupply, ATDDemand, ATDSupply, Echo), register Redis Pub/Sub channel URIs (e.g., demand:atc-2, supply:atd-2), and set up JSON serialization via Jackson (including a custom ClusterKeyDeserializer). The change also introduces supporting infrastructure such as the CommandType enum for protocol codes, serialization logic for CollectorState, and utility classes for throttling (MinTermThrottle) and thread naming (PrefixThreadFactory).

realtime/realtime-common · high confidence

This update introduces three new Redis-backed channel implementations for inter-component communication: a key-value channel (scheme 'kv') that uses polling for subscriptions, a pub/sub channel (scheme 'pubsub') leveraging Redis native pub/sub for real-time messaging, and a stream channel (scheme 'stream') utilizing Redis Streams with consumer groups for reliable message delivery. These are registered via dedicated Spring configurations (RedisKVChannelConfig, RedisPubSubConfig, RedisStreamConfig) and rely on a new foundational Redis configuration (RedisBasicConfig) that sets up the Lettuce connection factory, reactive templates, and disables native kqueue transport.

redis · high confidence

This release introduces a new Pinpoint profiler plugin for the Redisson client (versions 3.10.0 to 3.10.4). The plugin automatically instruments Redisson's synchronous, asynchronous, and reactive APIs to capture distributed traces, including endpoint details and optional key tracing. It supports both standard async context injection and a new 'wrapping' mode for reactive publishers (Mono/Flux), which can be enabled via the \profiler.redis.redisson.wrap.publisher\ configuration flag to ensure trace context is carried through the reactor pipeline. The plugin is enabled by default and can be configured with \profiler.redis.redisson.enable\ and \profiler.redis.redisson.keytrace\.

agent-module/plugins/redis-redisson · high confidence

This change introduces a new profiler plugin for Spring Boot applications, enabling automatic detection and tracing. The plugin detects Spring Boot apps by checking for specific launcher classes (JarLauncher, WarLauncher, PropertiesLauncher) or the @SpringBootApplication annotation, with the list of expected main classes configurable via profiler.springboot.bootstrap.main. It instruments the Spring Boot Launcher to capture service metadata, including the loaded library JAR names, and registers a dedicated service type (SPRING\_BOOT) for trace visualization. The plugin is enabled by default (profiler.springboot.enable=true) and supports Spring Boot versions from 1.2 up to 4.1.max.

agent-module/plugins/spring-boot · high confidence

This change introduces a new Pinpoint agent plugin that automatically instruments Spring Data R2DBC applications to capture distributed traces for reactive database operations. The plugin supports a wide range of R2DBC drivers, including PostgreSQL, MySQL (via dev.miku and io.asyncer), MariaDB, H2, Oracle, and MS SQL Server. It intercepts connection creation, statement binding, and execution to record database service types, endpoints, and bind variables, while also propagating async context across reactive Publisher seams to maintain trace continuity. Users can enable the plugin via the \profiler.spring.data.r2dbc.enable\ configuration flag.

agent-module/plugins/spring-data-r2dbc · high confidence

A new testweb application has been added to validate the Spring Data R2DBC plugin across H2, MySQL, MariaDB, PostgreSQL, MSSQL, and Oracle databases. This module provides a Spring Boot server with REST endpoints for database operations and includes specific database connection components for each supported dialect, along with Docker-based integration tests to verify plugin behavior against these diverse data stores.

agent-module/agent-testweb/spring-data-r2dbc-plugin-testweb · high confidence

This change introduces a new Tomcat plugin that enables automatic detection and tracing of Tomcat-based applications (versions 8 through 10). The plugin instruments key Tomcat components to capture server metadata (such as protocol, port, and server info), track HTTP request/response details, and support Servlet 3.0+ asynchronous processing for both javax and jakarta namespaces. It also provides configuration options to hide Pinpoint headers, exclude specific URLs or HTTP methods from tracing, and collect URI statistics.

agent-module/plugins/tomcat · high confidence

The \uristat-web\ module introduces a new web layer for URI statistics, exposing REST endpoints at \/api/uriStat/summary\ and \/api/uriStat/chart\. These endpoints allow users to retrieve paginated URI summaries and detailed chart data (total, failure, latency, and apdex) for specific applications. The implementation uses a new Spring configuration (\UriStatWebConfig\) to wire up MyBatis mappers against a Pinot data source, supporting configurable query periods and time ranges.

uristat/uristat-web · high confidence

The agent now includes a new 'User' plugin that allows users to define custom entry points and message queue client handlers for profiling. Users can configure the \profiler.include\ property to specify fully qualified class and method names to be treated as entry points, and the \profiler.message.queue.client.handler.methods\ property to define methods that invoke message queue callbacks. The plugin automatically instruments these methods to create trace spans, enabling visibility into custom application logic and asynchronous message processing.

agent-module/plugins/user · high confidence

This release introduces a new profiling plugin for Vert.x applications, enabling automatic tracing of HTTP server and client requests. The plugin supports Vert.x versions 3.3 through 4.5, with specific configuration options to handle method name mapping for different router implementations (e.g., \RouterImpl.handle\ vs \RouterImpl.accept\). It provides comprehensive instrumentation for HTTP headers, cookies, and request parameters, while also supporting async context propagation for \executeBlocking\ and \runOnContext\ operations to ensure correct trace linking in asynchronous workflows.

agent-module/plugins/vertx · high confidence

The agent-testweb area now includes three new Spring Boot applications to support testing: agentsdk-async-testweb, closed-module-testweb, and thread-plugin-testweb. The agentsdk-async-testweb module exposes REST endpoints (e.g., /sdk-async-plugin/manual-context-propagation, /sdk-async-plugin/auto-context-propagation) that use Pinpoint SDK classes like TraceExecutors, TraceRunnable, and TraceCallable to verify async context propagation. The closed-module-testweb module provides a /closed endpoint that invokes a closed-module test library (ClosedService) to test tracing across module boundaries. The thread-plugin-testweb module exposes endpoints (e.g., /thread-plugin/supplyAsync, /thread-plugin/springAsync) to test thread plugin behavior with CompletableFuture and Spring @Async. All modules are configured to run on port 18080 with Swagger UI enabled.

(repo-wide) · high confidence

The alarm module has been split into its own batch module, introducing a scheduled job that evaluates alarm rules and dispatches notifications via email and webhooks. The batch job classifies evaluation failures as either rule configuration errors (reported to the rule owner) or infrastructure issues (suppressed to avoid noise), and uses a separate scheduler to drain the notification outbox independently, ensuring that slow or failing network calls do not block the next evaluation sweep.

alarm/alarm-batch, alarm/alarm-common, alarm/alarm-web · high confidence

The commons-buffer module introduces a new \AutomaticBuffer\ that automatically expands its underlying array when writing data, alongside \OffsetAutomaticBuffer\ and \OffsetFixedBuffer\ which support explicit start/end offsets for windowing over shared byte arrays. A new \StringAllocator\ interface and \CachedStringAllocator\ implementation allow for LRU-cached string allocation during decoding, improving performance when reusing identical string values. The \FixedBuffer\ now rejects embedded NUL bytes in null-terminated strings to prevent parsing ambiguity, and \ByteArrayUtils\ provides new low-level utilities for byte array operations.

commons-buffer · high confidence

The uristat-batch module now includes a new Spring Batch job that monitors URI performance metrics and triggers alarms. This job reads registered alarm keys, collects real-time data for total count, failure count, Apdex, average response time, and maximum response time from Pinot, evaluates them against configured rules, and sends notifications via SMS, email, or webhook when thresholds are breached.

uristat/uristat-batch · high confidence

A new channel module has been added to abstract message transport across distributed systems, supporting backends like Redis and Kafka via a URI-based provider registry. It introduces a publish/subscribe channel model and a ChannelService framework that enables demand-supply interactions (similar to RPC) between system parts, with support for both single-response (Mono) and multi-response (Flux) service protocols.

channel · high confidence

The new collector-monitor module adds runtime observability for the collector by wiring Micrometer metrics for HBase client operations, thread pool activity, and network I/O. HBase client-side metrics (counters, timers, gauges, histograms) are now collected through HBaseMetricsConfiguration and HBaseMetricsAdapter, which bridge HBase's internal MetricRegistry to the Micrometer MeterRegistry. Thread pool execution is monitored via MonitoredThreadPoolExecutor and MicrometerThreadPoolExecutorFactory, exposing submitted, running, completed, and rejected task gauges, along with logging and counting for rejected executions. Network interface statistics (bytes and packets sent/received) are bound to Micrometer through NetworkMetricsBinder. Additionally, bulk operation and HBase async operation metrics are exposed via BulkOperationMetrics and HBaseAsyncOperationMetrics, and gRPC server interceptors tag metrics by service (agent, span, stat).

collector-monitor · high confidence

The commons-server module introduces new Spring configuration classes (CommonsHbaseConfiguration, CommonsServerConfiguration) that wire up HBase row key encoders, time slots, and Jackson modules, alongside a set of typed annotation value objects (e.g., BinaryAnnotationBo, StringAnnotationBo) and application map domain models (Vertex, UidAgentRowKey, UidAppRowKey) that support UID-based row key generation and statistics storage.

commons-server · high confidence

The commons-profiler module introduces a suite of new utility classes to improve performance and observability. A millisecond-precision Clock interface (with System, Fixed, and Tick implementations) provides a replaceable time source for profiling. A new ThrottledLogger replaces the previous call-count-based approach with time-based throttling (via TimeLogThrottle and CountingTimeLogThrottle) to prevent log bursts under load, while also supporting uncounted intervals. Concurrent data structures, including ConcurrentReferenceHashMap and ConcurrentWeakHashMap, are added for advanced garbage-collection semantics, alongside an AsyncQueueingExecutor for background processing and an ExecutorFactory with a PinpointThreadFactory for standardized thread creation. Finally, an IOUtils helper adds safe closeQuietly methods.

commons-profiler · high confidence

The collector now includes a new \exceptiontrace-collector\ module that enables capturing and storing exception trace data in Pinot. This feature is controlled by the \pinpoint.modules.collector.exceptiontrace.enabled\ property. When enabled, the collector receives exception metadata via Kafka (topic \exception-trace\), maps the incoming data to Pinot entities, and persists it. The module includes configuration for Kafka producers, DAOs for Pinot insertion, and mappers for transforming stack traces and error messages. A configurable option \pinpoint.collector.exceptiontrace.replace.characters\ (defaulting to true) allows sanitizing error messages to retain only ASCII characters.

exceptiontrace/exceptiontrace-collector · high confidence

This release introduces a new gRPC plugin for Pinpoint that enables distributed tracing for both gRPC clients and servers. The plugin instruments key gRPC internal classes to capture request metadata, remote addresses, and method names for client calls, and tracks server-side stream creation and listener events. It supports configuration via properties such as \profiler.grpc.client.enable\ and \profiler.grpc.server.enable\, and includes specific handling for streaming scenarios with options to control message-level tracing. This allows users to visualize gRPC service dependencies and performance in their Pinpoint dashboards.

agent-module/plugins/grpc · high confidence

A new test web application has been added to the agent module to facilitate testing of the gRPC plugin. This service includes a Spring Boot starter, a REST controller exposing endpoints to trigger gRPC calls, and embedded gRPC servers and clients. It supports both standard unary RPCs and bidirectional streaming with manual flow control, allowing developers to verify agent behavior against these specific gRPC interaction patterns.

agent-module/agent-testweb/grpc-plugin-testweb · high confidence

A new test-only module, hbase-testcluster, has been added to allow components depending on HBase to be tested in-process without requiring a real cluster. It wraps Apache HBase's TestingHBaseCluster to boot a MiniCluster (HBase, HDFS, ZooKeeper) for the lifetime of an integration test. The module provides a Spring configuration (HbaseTestClusterConfiguration) that registers beans for the cluster, HBase configuration, and both synchronous and asynchronous HBase connections, alongside a standalone Java API for non-Spring environments. It also includes helper methods for creating tables and namespaces, and configures logging to mute Hadoop/HBase noise by default.

hbase-testcluster · high confidence

The plugin integration test utilities now include a suite of helper classes to support modern testing workflows. Testcontainers support is expanded with a centralized version constant and explicit dependency definitions for databases (MySQL, PostgreSQL, etc.), messaging systems (Kafka, RabbitMQ, Pulsar), and utilities for Docker image pulling and architecture detection. HTTP testing capabilities are enhanced with a new HeaderRecordingWebServer that captures request headers to verify agent propagation, alongside a standard WebServer wrapper. Additional utilities include an ExecutorService shutdown helper, a System.out recorder, and a Testcontainers log output stream, while older line-break removal logic is deprecated in favor of Testcontainers' native methods.

agent-module/plugins-test-module/plugins-it-utils/src/main · high confidence

The log/log-collector module has been introduced to enable real-time log streaming from agents to the collector. It provides a gRPC-based connection handler that accepts log piles and propagates agent headers (hostname, filename) via a custom interceptor, alongside a Redis-based pub/sub server that broadcasts available log files and supports live tailing via Flux streams. Configuration is handled through Spring Boot property sources for gRPC bind addresses, executors, and Redis channel settings, allowing users to stream and consume log data in real time.

log/log-collector · high confidence

This change introduces a new live-tail capability for application logs in the Pinpoint web UI. Users can now stream log entries in real-time via a new WebSocket endpoint at /log/liveTail, which accepts host group, host, and file name filters. Additionally, HTTP Server-Sent Events (SSE) endpoints are provided at /log/hostGroups/{hostGroup}/tail for streaming, along with helper endpoints to list available host groups and their associated hosts/files. The feature is controlled by the 'pinpoint.modules.log.enabled' property and relies on Redis for file key discovery and a channel service for log streaming.

log/log-web · high confidence

This update introduces new data models for metric points, including AvgMinMaxMetricPoint, AvgMinMetricPoint, and MinMaxMetricPoint, which support storing aggregated statistics (average, min, max) for time-series data. It also adds a comprehensive tag handling system with new Tag and Tags model classes, along with utilities for parsing and converting tags between string and JSON formats. Additionally, MyBatis type handlers (TagListTypeHandler, TagTypeHandler) and serializers (TagListSerializer, TagSerializer) are added to enable efficient JSON-based storage and retrieval of tag lists in the database, with Jackson core used for direct JSON streaming to improve memory efficiency.

metric-module/metric-commons · high confidence

This update introduces a new \NetworkAvailabilityChecker\ tool in the \agent-tools\ module to validate connectivity to Pinpoint collector endpoints (Base, Metadata, Stat, Span) via TCP checks, and adds a new \profiler-micrometer\ module that enables the agent to export JVM and system metrics to an OpenTelemetry-compatible endpoint using the Micrometer OTLP registry.

agent-module/profiler · high confidence

The agent module's plugin loader now exposes dedicated service interfaces and default implementations for managing trace metadata, specifically \AnnotationKeyRegistryService\ and \ServiceTypeRegistryService\. These components provide methods to look up annotation keys and service types by code or name, delegating to underlying locators, and are supported by a new \PinpointPluginLoader\ interface and test resources for validating type provider configurations.

agent-module/plugins-loader · high confidence

Added two new profiler plugins to the agent module. The Jackson plugin (agent-module/plugins/jackson) instruments com.fasterxml.jackson.databind and org.codehaus.jackson classes to trace JSON serialization and deserialization, recording the length of the data processed via the profiler.json.jackson configuration flag. The Process plugin (agent-module/plugins/process) instruments java.lang.ProcessBuilder.start() to trace external process execution, recording the command line and process ID (PID) via the profiler.process.tracing.enabled configuration flag, with PID detection adapted for Java 9+ and older JVMs on Unix/Windows.

agent-module/plugins/jackson, agent-module/plugins/process · high confidence

The agent now includes new plugins to parse and record proxy request metadata for Apache, Nginx, internal app proxies, and custom user-defined proxies. This adds support for parsing specific HTTP headers (Pinpoint-ProxyApache, Pinpoint-ProxyNginx, Pinpoint-ProxyApp, and configurable user headers) to extract timing, duration, and load information, enabling more detailed distributed tracing across proxy layers.

(repo-wide) · high confidence

A new Spring Boot-based test application has been added to the quickstart directory to serve as a target for Pinpoint agent instrumentation. It includes controllers that generate various load patterns (CPU, memory, sleep, random latency, failures), perform external HTTP calls (Google Geocode, EPL League Table), and invoke self-calls over HTTP. The app also exposes an API listing page and supports URI template metrics via request attributes, running on port 8082.

quickstart/testapp · high confidence

This change introduces the service-module, which provides a new service registry capability and web integration. It adds a REST API (ServiceRegistryController) for managing custom services (insert, list, delete) backed by a MySQL database via MyBatis, including schema and DAO layers. It also introduces a web argument resolver (@ServiceParam) that allows controllers to inject a ServiceName by extracting it from HTTP headers, cookies, or query parameters, with a fallback to a default service.

service-module · high confidence

The agent now includes dedicated plugins to trace the Google HTTP Client Library for Java and Apache HttpClient 3.x. For Google HTTP Client, the plugin instruments synchronous and asynchronous request execution, supporting nested async contexts and configurable error marking. For Apache HttpClient 3.x, the plugin traces method execution, HTTP connections, and retry handlers, with options to record request parameters, cookies, and request entities.

agent-module/plugins/httpclient3 · high confidence

The web-frontend/src/main/v3/apps/web directory now contains the complete entry point and layout structure for the v3 web application. This includes the React application bootstrap (main.tsx), a new Tailwind CSS v4 styling setup, and a dedicated ESLint configuration. The application uses React Router v7 for nested layout routes, replacing the previous Higher-Order Component pattern with dedicated layout components (InitialFetchOutlet, SideNavigationOutlet, ConfigurationOutlet) that handle configuration fetching, service synchronization, and menu rendering. Additionally, a temporary development mock server (dev-mock) has been added to simulate cross-service service map interactions locally.

web-frontend/src/main/v3/apps/web · high confidence

The Quickstart module now ships with an Apache Maven Wrapper (mvnw), allowing users to build and run the sample TestApp without manually installing Maven. The wrapper is configured to use Maven 3.9.9 and requires the JAVA\_HOME environment variable to be set correctly on the system. Additionally, a new README.md has been added to guide users through the Docker-based installation and manual build steps for the Pinpoint Agent and TestApp.

quickstart · high confidence

The RabbitMQ plugin now traces custom consumer implementations (beyond the default DefaultConsumer and QueueingConsumer) when their fully qualified class names are listed in the profiler.rabbitmq.client.consumer.classes configuration option. It also adds instrumentation for Spring AMQP (spring-rabbit) classes, including RabbitTemplate and BlockingQueueConsumer, to capture message delivery spans. Additionally, users can now exclude specific exchanges from tracing via the profiler.rabbitmq.client.exchange.exclude configuration option.

agent-module/plugins/rabbitmq · high confidence

The OTLPTRACE collector now accepts OTLP logs via gRPC (LogsService/Export) and HTTP (POST /v1/logs), co-hosted on the same transport endpoints as traces. It filters incoming logs to retain only those carrying exception attributes, deduplicates them within the request, and maps the surviving records into the existing Error Analysis storage (ExceptionMetaDataBo), making exception logs visible in the same Error Analysis table and web views as exceptions derived from span events. The receiver uses its own admission budgets, worker pool, and metrics (tagged service=otlplog) to isolate back-pressure from the trace path, and reports client-visible rejections (e.g., invalid resource, no trace context, mapping error) in the OTLP partial-success response.

otlplog/otlplog-collector · high confidence

The profiler now supports running on JDK 9 and later by introducing a dedicated module that handles JDK-specific internal APIs. This includes a new Java9DefineClass implementation to define classes via the JDK 9+ SharedSecrets mechanism, a JavaLangAccessHelper that dynamically selects the correct internal access path for JDK 9 versus JDK 11+, and a Java9ShutdownHookRegister to manage shutdown hooks using these internal APIs. Stub classes for jdk.internal.misc and jdk.internal.access are included to ensure compilation compatibility, and unit tests verify the new class loading and hook registration paths.

agent-module/profiler-optional/profiler-optional-jdk9 · high confidence

Added utility classes and MyBatis type handlers to support inspector data handling in Pinot. SortKeyUtils provides methods to generate sort keys for agent and application statistical data, ensuring keys match partition requirements. MultiValueTagTypeHandler enables parsing of JSON-formatted tag lists from database results into Tag objects, with corresponding unit tests verifying the parsing logic.

inspector-module/inspector-commons · high confidence

The webhook functionality has been extracted into its own module, making it a standalone, opt-in feature controlled by the property pinpoint.modules.web.webhook. This introduces a new REST API under /api/webhook and /api/application/webhook for managing webhook configurations (create, read, update, delete) and a separate API under /api/webhookSendInfo and /api/application/webhookSendInfo for managing webhook-to-alarm-rule mappings. The Webhook model now uses applicationName instead of applicationId (with the old getter/setter deprecated), and webhook URLs are validated on input. Alarm rule changes now automatically update webhook send info via an event listener, and the module includes MySQL DAOs and in-memory test implementations.

webhook · high confidence

The application map's data access layer has been reorganized into a new modular structure to support V3 storage logic. This change introduces dedicated Spring configuration classes (MapDaoConfiguration and MapV3DaoConfiguration) to manage Hbase connections, templates, and scan factories, alongside new DAO interfaces and their Hbase implementations for host applications, agent response times, and in/out links. Users benefit from a cleaner separation of concerns in the backend, which prepares the system for improved performance and maintainability of the application map views.

applicationmap · high confidence

The application banner has been separated into its own module, introducing a new \pinpoint-banner\ component. This change includes a new \Banner\ interface, a \PinpointBanner\ implementation with a builder pattern, and a \BannerSupplier\ to load the ASCII art from \banner.txt\. Users can now configure the banner output mode (OFF, CONSOLE, or LOG) and specify which system properties to display alongside the version string, allowing for more flexible startup logging behavior.

banner · high confidence

The batch module has been refactored to use Spring Boot for application startup and Java-based configuration instead of XML. A new entry point, BatchApp, initializes the Spring context and excludes unnecessary auto-configurations, while BatchModule and BatchServiceModule define the component scan and bean wiring. Configuration is now loaded via BatchAppPropertySources from batch-root.properties and profile-specific files. The alarm processing logic has been rewritten with new classes (AlarmReader, AlarmProcessor, AlarmWriter) and a factory-based checker registry, replacing the previous XML-driven setup.

batch · high confidence

The HBase access layer has been extracted into a new \commons-hbase\ module, providing a shared foundation for Pinpoint's HBase interactions. This change introduces a new abstraction layer built on the HBase 2 client API, featuring Spring-based factory beans for connection and configuration management, a dedicated admin template for schema operations, and a comprehensive set of table definitions (V2 and V3) for the collector's data model. It also includes new utilities for row key distribution, scan handling, and security providers, establishing the core infrastructure for the upcoming HBase 2 migration.

commons-hbase · high confidence

The web module now includes Spring Boot Actuator for built-in health and metrics endpoints, and restructures its internal configuration into a modular architecture via PinpointWebModule, AuthorizationConfig, and dedicated sub-modules (e.g., AgentListModule, HeatmapWebModule). This improves maintainability and provides standard operational visibility without changing user-facing features.

web · high confidence

The bootstrap core module has been restructured to introduce a new classloader hierarchy and improved async context handling. A new \ParallelClassLoader\ and associated factories (\PinpointClassLoaderFactory\, \DynamicClassLoaderFactory\) replace previous loading mechanisms, enabling better isolation and parallel capability for agent classes. Additionally, new \AsyncContextAccessor\ and \AsyncContextAccessorUtils\ classes provide a standardized way to manage async context propagation across different object types, supporting more robust tracing in asynchronous execution environments.

agent-module/bootstraps/bootstrap-core/src/main · high confidence

The pinot-batch module now uses a Java-based Spring configuration (PinotBatchDaoConfig) to wire MyBatis for alarm processing, replacing previous XML-based batch configurations. This change introduces the DAO layer (PinotAlarmDao and its MySQL implementation) and supporting value objects (PinotAlarmKey, PinotAlarmRule, PinotAlarmHistory) required to read alarm rules and persist alarm history. It also adds MyBatis configuration (pinot-alarm-mybatis-config.xml) and mapper resources (PinotAlarmMapper.xml) for the alarm domain, along with MySQL driver properties to tune statement caching and timeouts for these new data-access paths.

pinot/pinot-batch · high confidence

The spring-stub module now includes stub interfaces for Spring's HTTP types, specifically HttpRequest, HttpStatusCode, and ClientHttpResponse (for both standard and reactive clients). These additions provide the necessary type definitions to support Spring WebFlux compatibility, ensuring the agent can correctly handle HTTP method and status code interactions across different Spring versions.

agent-module/plugins/spring-stub · high confidence

The agent now includes a VERSION file exposing the build version, introduces profile alias support for agent configurations, and switches the default NameVersion module to v3. Logging is enhanced with a new YAML-based log4j2 configuration (log4j2-agent.yaml) alongside the existing XML format, adding configurable options for log file size, last modified age, and rollover strategy maximums. Additionally, the default JVM stat collection interval has been increased to 10 seconds, and gRPC span transmission now defaults to the batch unary SendSpanList RPC instead of the stream-based approach.

agent-module/agent/src/main/resources · high confidence

The bootstrap module has been reorganized to introduce a new agent initialization flow. This includes the addition of \AgentBootLoader\ and \PinpointStarter\ to manage the agent lifecycle, \AgentOption\ and \DefaultAgentOption\ to encapsulate configuration and instrumentation data, and \AgentType\ to support different agent modes (e.g., default vs. plugin test). The \PinpointBootStrap\ entry point now utilizes these components to resolve agent directories, load properties, and start the agent, while \ModuleBootLoader\ and \ModuleUtils\ handle Java module system support. Additionally, utility classes like \ArgsParser\, \BootLogger\, and \PathUtils\ have been added to support argument parsing, logging, and path manipulation during bootstrap.

agent-module/bootstraps/bootstrap · high confidence

The collector-starter module has been refactored to allow starting specific collector components (BASIC, METRIC, LOG, OTLPTRACE) independently rather than launching the entire suite by default. A new \PinpointCollectorStarter\ entry point parses the \--pinpoint.collector.type\ argument (or uses a Spring Shell fallback) to determine which sub-applications to initialize, enabling users to run only the services they need. This change also introduces a standalone \OTLPTRACE\ collector type that handles OpenTelemetry trace and log ingestion on port 9997, decoupled from the legacy metric collector, and updates the default configuration to enable the service feature and health probes for better operational visibility.

collector-starter · high confidence

The HBase deployment scripts and Docker configuration have been updated to support the TraceV2 format and new metadata tables. The schema creation scripts now include \SqlUidMetaData\ and \TraceV2\ tables, and the \ApplicationTraceIndex\ table now uses a two-column family design (I and M). Additionally, the Docker setup includes a new \configure-hbase.sh\ script that allows runtime configuration of Time-To-Live (TTL) values for all Pinpoint tables via environment variables, and the \hbase-create-snappy.hbase\ script now enables Snappy compression and prefix data block encoding for improved storage efficiency.

hbase · high confidence

The Reactor plugin now uses a new \SeamPublisherWrapper\ and \TracedSubscriber\ to wrap reactive publishers returned from I/O seams. This ensures that every signal is delivered inside a trace window bound to the seam's \AsyncContext\, preventing cross-subscription trace leaks when applications reuse publishers. The implementation also handles nested seams by having the source-side seam win trace binding, and ensures that scalar publishers and specific reactor types like \ConnectableFlux\ are left alone to preserve performance and subtype integrity.

agent-module/plugins/reactor · high confidence

The inspector collector has been refactored to decouple agent and application statistical data into distinct Kafka topics. This change introduces dedicated Kafka templates and configuration properties for agent and application stats, allowing the collector to write agent metrics (such as CPU, GC, and transaction counts) to a partitioned agent topic and application-level metrics to a separate application topic. The new \DefaultAgentStatDao\ and \PinotAgentStatService\ handle this separation, ensuring that data is correctly routed based on the new topic configuration while maintaining the existing Pinot storage pipeline.

inspector-module/inspector-collector · high confidence

The Kafka plugin has been updated to support Apache Kafka versions up to 3.x (with a stated range extending to 3.max) and restructured to improve compatibility with Kafka 4.x. This change introduces a new \KafkaConfig\ class that centralizes plugin settings, adding specific configuration options for Spring Kafka's \KafkaMessageListenerContainer\ entry point (\profiler.springkafka.container.enable\) and error marking (\profiler.springkafka.container.mark.error\). The plugin now includes a \KafkaClientUtils\ helper to dynamically detect header support in Kafka client versions, ensuring correct tracing behavior for producers and consumers. Additionally, the entry point logic for Kafka Streams and Spring Kafka consumers has been refined to provide more accurate service type mapping and trace context propagation.

agent-module/plugins/kafka · high confidence

The MariaDB JDBC profiling plugin has been updated to support the MariaDB Java Client 3.x series, extending the supported driver range to \[1.1, 3.1\]. This change introduces a new plugin module that instruments the updated \org.mariadb.jdbc\ class hierarchy (including \Connection\, \ServerPreparedStatement\, and \ClientPreparedStatement\) to ensure transaction and statement profiling remains functional with the newer driver versions.

agent-module/plugins/mariadb-jdbc · high confidence

The MongoDB agent plugin has been updated to support the MongoDB Java Driver versions 2.0 through 5.6.x. This update includes new interceptors and class transformations for the reactive streams driver (specifically targeting versions 4.2+ and 5.6+), ensuring that asynchronous and reactive database operations are correctly traced. The plugin now handles internal class changes in newer driver releases, such as \MongoClientImpl\ and \FindPublisherImpl\, to maintain accurate distributed tracing for modern MongoDB applications.

agent-module/plugins/mongodb · high confidence

The MySQL JDBC plugin has been rewritten to support the modern MySQL Connector/J 9.x (mysql-connector-j) driver, replacing the legacy driver. This update introduces a new \MySqlJdbcUrlParser\ for robust JDBC URL parsing (including load-balanced connections), dedicated interceptors for MySQL 6.x+ and 8.x+ connection constructors, and updated service type definitions. Users benefit from improved compatibility with recent MySQL driver versions and more accurate tracing of connection details.

agent-module/plugins/mysql-jdbc · high confidence

The agent now ships with dedicated configuration profiles for local and release environments, allowing users to select the active profile via the \-Dpinpoint.profiler.profiles.active\ system property. The local profile is tuned for development with a 10-second JVM stat collection interval, 100% sampling rate, and detailed metrics enabled. The release profile is optimized for production with a 10-second collection interval, a 5% sampling rate, and detailed metrics disabled. Both profiles enable the new monomorphic exception-guard codegen by default to improve interceptor performance and include a \.gitignore\ to exclude private and custom profile directories.

agent-module/agent/src/main/resources/profiles · high confidence

The alarm module now includes a dedicated data-access layer for agent-stat alarms, introducing a new MyBatis mapper (AlarmAgentStatMapper.xml) and DAO implementation (PinotAgentStatAlarmDao) that query Pinot for agent usage metrics. To prevent Pinot's default 10-row limit from silently truncating results, the mapper explicitly sets a LIMIT of 100,000 on the group-by-agent queries (selectSumGroupByField, selectSumCount, selectAvg), ensuring that alarm rules can evaluate all agents rather than just the first ten. The change also adds supporting value objects (AgentUsage, AgentFieldUsage, AgentUsageCount), a query-parameter model, and a MyBatis registry handler to register the necessary type aliases and handlers, along with a test that verifies the mapper is discoverable and all DAO statements are defined.

alarm/alarm-core · high confidence

The datasource module now provides a dedicated configuration for the main and metadata data sources using HikariCP. Users can configure connection properties via standard Spring Boot properties (e.g., \spring.datasource.hikari.\\ and \spring.meta-datasource.hikari.\\). Default values are set in \jdbc-root.properties\, including a maximum pool size of 128, connection timeout of 5000ms, and specific MySQL driver optimizations. Profile-specific overrides are available for 'local' and 'release' environments, allowing easy switching of JDBC URLs and credentials.

datasource · high confidence

The OkHttp plugin has been restructured to specifically target OkHttp 2.x (com.squareup.okhttp/okhttp \[2.0, 2.7\]), introducing a new v2 implementation package. This change adds dedicated interceptors for async operations (AsyncCallExecuteMethodInterceptor, DispatcherEnqueueMethodInterceptor) to better trace asynchronous requests, and introduces a \markError\ configuration option (\profiler.okhttp.mark.error\) to control whether exceptions mark the trace as an error. The plugin now uses a new \OkHttpPluginConfig\ to manage settings like cookie dumping, parameter recording, and status code recording, and includes new utility classes like \EndPointUtils\ and \OkHttpConstants\ to support the updated instrumentation logic.

agent-module/plugins/okhttp · high confidence

The realtime collector functionality is now opt-in rather than automatic. The new \RealtimeCollectorModule\ Spring configuration registers empty, no-op implementations for the command service and cluster point locator when the \pinpoint.modules.realtime.enabled\ property is false or missing. This means the realtime collector will not start or consume resources unless explicitly enabled via configuration.

realtime/realtime-collector · high confidence

The realtime web module has been refactored to support Redis-based communication for Active Thread Count, Active Thread Dump, and Echo features. This change introduces new Spring configuration classes (RealtimeWebCommonConfig, RedisRealtimeWebModule) that wire up Redis-backed Data Access Objects (ActiveThreadCountDao, ActiveThreadDumpDao, EchoDao) using the channel service client. Users benefit from a consistent, Redis-pubsub driven backend for these realtime web capabilities, replacing previous implementations and enabling features like durable active thread count updates and agent name exposure in responses.

realtime/realtime-web · high confidence

The profiler-logging module has been refactored to improve configuration flexibility and type support. The logging system now searches for and supports both XML and YAML formats for the agent configuration file (log4j2-agent.yaml), allowing users to choose their preferred configuration style. Additionally, the logger adapter has been updated to recognize and safely handle Java 8 Date/Time types (such as LocalDateTime and Instant) as simple types, ensuring they are logged correctly without side effects.

agent-module/profiler-logging · high confidence

The batch-alarmsender module has been refactored to replace XML-based configuration with Spring Java configuration (AlarmSenderConfiguration), introducing explicit beans for mail, webhook, and HTTP client setup. Webhook payloads now use 'applicationName' instead of the deprecated 'applicationId', and the webhook payload no longer includes user group information. Additionally, webhook URLs are now validated for SSRF protection, and the pinpoint link in email alarms has been updated.

batch-alarmsender · high confidence

The RestTemplate plugin has been rewritten to support Spring Framework 7.0 and Spring Boot 4.1. This update introduces a new version detection mechanism (SpringVersion) that distinguishes between Spring 5, 6, and 7, allowing the plugin to adapt its behavior accordingly. Key changes include support for the new Iterable-based RestTemplate constructor in Spring 7, a refactored header adaptor (RestTemplateResponseHeaderAdaptor) to prevent NoSuchMethodError caused by HttpHeaders changes in Spring 7, and updated status code providers to handle the shift from HttpStatus to HttpStatusCode. The plugin now correctly instruments async requests and response handling across all supported Spring versions.

agent-module/plugins/resttemplate · high confidence

The datetime-picker package has been rewritten from Angular to React, introducing the RichDatetimePicker component with a new DatePanel for time-unit selection and a DatePicker for calendar range picking. This update includes support for custom time views, timezone-aware date handling via date-fns-tz, and a new 'More' panel that opens beside the field. The component now uses Tailwind CSS for styling and Storybook v9 for documentation, with configuration files for ESLint, Prettier, and Jest added to the package.

web-frontend/src/main/v3/packages/datetime-picker · high confidence

The scatter-chart package has been restructured to align with the monorepo's modern tooling. Storybook configuration has been migrated to ESM using the \@storybook/html-vite\ framework, and a comprehensive set of stories (including default, interactions, realtime, and theme customization) has been added to facilitate component development and testing. Development workflows are standardized with new ESLint and Prettier configurations, alongside a Jest setup that handles ESM/CJS interoperability for testing. Additionally, the package now exposes explicit default configuration constants for axes, points, legends, and guides, providing a consistent baseline for chart rendering.

web-frontend/src/main/v3/packages/scatter-chart · high confidence

The Server Map library has been rewritten from Angular to React, introducing a new \ServerMap\ component that renders application topology using Cytoscape.js. This update adds Storybook integration for component development and includes new visualization features: service group nodes are now rendered with a centered name/count and are 30% larger, and Apdex scores are applied to server map nodes and time-series data. The component also supports custom node/edge labels, node merging logic, and theme customization via a provided \defaultTheme\ and \ServerMapTheme\ types.

web-frontend/src/main/v3/packages/server-map · high confidence

The common-servlet plugin now includes a parallel set of adapter classes under the \jakarta\ package (e.g., \HttpServletRequestAdaptor\, \HttpServletResponseAdaptor\, \HttpServletParameterExtractor\) to support Jakarta EE 9+ servlet containers alongside the existing \javax.servlet\ implementations. Additionally, the plugin's real-IP resolution logic has been updated to support the RFC 7239 \Forwarded\ header and allows the \realipheader\ configuration to be specified as a list of headers (e.g., \forwarded, x-forwarded-for\) to define a priority order for resolving the client's remote address.

agent-module/plugins/common-servlet · high confidence

The Spring WebFlux profiler plugin has been updated to support Spring Framework 7.0 and Spring Boot 4.1, extending the supported range to include versions up to 7.0.max and 4.1.max respectively. To ensure compatibility with Spring 7.0, which removed the \MultiValueMap\ implementation from \HttpHeaders\ (causing \NoSuchMethodError\ on methods like \get(Object)\ and \keySet()\), the plugin now uses version-safe header accessors that rely only on methods present across Spring 5, 6, and 7. Additionally, the plugin introduces a \SpringVersion\ detector to automatically identify the running Spring version and applies appropriate interceptors and configuration gates for reactor publisher wrapping and async context handling.

agent-module/plugins/spring-webflux · high confidence

The Spring plugin has been restructured to support Spring Framework 5.0 through 7.0 (and Spring Boot 4.1), dropping support for Spring 4. This includes new async tracing capabilities for Spring @Async (tracking task executors and async execution) and a reorganized beans module with configurable component-scan and post-processor scopes, along with updated configuration options and internal refactoring (e.g., PLogger to PluginLogger, string index handling).

agent-module/plugins/spring · high confidence

The testcase module has been moved from its previous location into the agent-module directory structure. This change reorganizes the project layout, placing the test case utilities (such as SocketUtils for finding available TCP/UDP ports) under agent-module/plugins-test-module/testcase, which may affect how these components are referenced or built within the agent context.

agent-module/plugins-test-module/testcase · high confidence

The Thrift profiler plugin has been updated to support Apache Thrift versions up to 0.21. This change replaces deprecated APIs and refactors internal implementations, such as swapping EnumSet usage for Enum.values() caches, to ensure stable tracing of both synchronous and asynchronous Thrift client and server calls.

agent-module/plugins/thrift · high confidence

The trace metadata provider loader in the agent module has been rewritten to use Jackson instead of SnakeYAML for parsing YAML configuration files, and now deduplicates identical type-provider definitions by content hash to prevent duplicate loading when the same file is visible via multiple classpath entries. This change introduces a new loader and parser architecture that reads service type and annotation key definitions from META-INF/pinpoint/type-provider.yml files, ensuring consistent and efficient trace metadata initialization.

agent-module/plugins-loader/src/main/java/com/navercorp/pinpoint/loader/plugins/trace · high confidence

The URI stat collector in the Pinpoint collector module has been refactored to load Kafka topic settings via Spring profiles rather than a static property source. A new \UriStatCollectorConfig\ activates only when \pinpoint.modules.collector.uristat.enabled\ is true and imports a \@PropertySource\ that resolves the topic configuration from \classpath:profiles/${pinpoint.profiles.active}/kafka-topic.properties\. This allows environment-specific topic definitions (e.g., \local\ vs \release\ profiles) to be used, with sample \kafka-topic.properties\ files provided for each profile to define the \kafka.uri.topic\ value.

uristat/uristat-collector · high confidence

The user module has been restructured to migrate package names to the Jakarta EE namespace and to ensure that user group deletion listeners are triggered after the database commit. This change introduces a \UserGroupDeletionListener\ interface and updates \UserGroupServiceImpl\ to invoke these listeners via \TransactionSynchronizationManager\ after a group is deleted, ensuring that any side effects (such as notifications or cleanup) occur only after the transaction is successfully committed.

user · high confidence

Add Ktor-based test web application for plugin testing; Add Spring Boot 3 WebFlux plugin test application; Add Spring WebFlux plugin test web application; Add integration tests for Oracle JDBC drivers (ojdbc8 and ojdbc10); Added Cassandra 3 and 4 plugin test web applications; Added HttpClient 5 plugin test web application; Added Jetty 12 test web applications for EE10 and EE11; Added Kafka plugin test web applications; Added OkHttp 4.x and 5.x plugin test web applications; Added OpenTelemetry SDK test applications for Micrometer Tracing, OTel Starter, and Spring Boot 4; Added Redis Lettuce plugin test web application; Added Spring Boot 2 async and bootstrap instrumentation test webapp; Added Spring Boot 4 WebFlux test application; Added Spring Boot 4 test web application; Added Spring Framework 6 integration tests for WebFlux and RestTemplate plugins; Added Spring Kafka plugin testweb; Added agent-proxy-plugin-testweb test harness; Added integration test for Fastjson plugin; Added integration test for Ning AsyncHttpClient plugin; Added integration test infrastructure for Thrift 0.14 plugin; Added integration tests for ActiveMQ client plugin; Added integration tests for Apache HttpClient 4.x plugin; Added integration tests for CXF client tracing; Added integration tests for Cassandra 2.x and 3.x drivers; Added integration tests for Cassandra 4.x DataStax driver; Added integration tests for ClickHouse JDBC plugin versions 0.3.2 through 0.9.x; Added integration tests for Elasticsearch 6.x and 7.x plugins; Added integration tests for Elasticsearch 7.16.x plugin; Added integration tests for Google HTTP Client and iBatis plugins; Added integration tests for HBase client operations; Added integration tests for JDK HttpURLConnection plugin; Added integration tests for Kafka client plugin across multiple versions; Added integration tests for Lettuce 6.7 and seam-wrap publisher tracing; Added integration tests for MariaDB JDBC driver versions 1.3 through 2.4; Added integration tests for MongoDB 3.x and 4.x driver plugins; Added integration tests for MyBatis SqlSession and SqlSessionTemplate; Added integration tests for Netty client plugins; Added integration tests for OkHttp 2.x through 5.x; Added integration tests for Pulsar client plugins (4.0.x and 4.1.x); Added integration tests for RabbitMQ client and Spring AMQP plugins; Added integration tests for Reactor plugin trace propagation and lifecycle; Added integration tests for Redisson reactive tracing and seam wrapping; Added integration tests for RxJava 1.x plugin support; Added integration tests for Spring Bean tracing with Lambda expressions; Added integration tests for Spring TX reactive transaction seam wrapping; Added integration tests for the Apache HttpClient 3 plugin; Added integration tests for the Commons DBCP plugin; Added integration tests for the HTTP Client 5 plugin; Added integration tests for the JTDS JDBC plugin; Added integration tests for the MSSQL JDBC plugin; Added test configuration files for agent integration tests; Added test infrastructure for agent profiler validation; Added test resource configurations for logging; Added test resources for bootstrap-core and MariaDB JDBC integration tests; Added test utility classes for generating API link pages; Added test web applications for Dubbo, Elasticsearch, HTTP clients, Jetty, Kafka, and MQTT plugins; Added tests for IsPinpointPackage classloader filter; Added tests for LibraryFinder utility; Added tests for Maven plugin integration components; Added tests for WebServer utility; Added tests for async context interceptor lifecycle and span event block handling; Added tests for trace metadata provider loading and YAML parsing; Added unit tests for HTTP, JDBC, and Reactor async context interceptors; Added unit tests for agent bootstrap and configuration components; Added unit tests for agent instrumentation filters and matchers; Added unit tests for bootstrap condition resolvers; Added unit tests for bootstrap configuration components; Added unit tests for bootstrap utility classes; Added unit tests for shared plugin test utilities; Added version templating for plugin test module; Integration tests added for Spring Framework 7 plugin support; New UI package scaffolding and end-to-end test coverage; Plugin test annotations and contracts moved to pinpoint-plugins-test-api.

This release updates dependencies across 357 manifests, including bumping Spring Framework from 6.1.16 to 6.1.20 and Spring Boot 3 from 3.5.5 to 3.5.14, upgrading Guava from 32.1.2-jre to 33.3.1-jre, and updating Jackson from 2.12.6 to 2.13.3. It also includes upgrades to HBase client, Log4j2, and various Maven plugins, alongside general dependency cleanup and removal of unused libraries to reduce build footprint.

(dependencies) · high confidence

The Maven Wrapper configuration has been updated to use version 3.3.4 of the wrapper script, which downloads and uses Apache Maven 3.9.16. This ensures that builds executed via the wrapper will consistently use this specific Maven version and distribution.

.mvn · high confidence

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

• CAI 48 → 49 (+0.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 87 → 88 (+0.5)
• Architecture 57 → 60 (+3.6)
• Maturity 68 → 67 (-0.2)
• Readiness 46 → 43 (-3.2)
• Security 54 → 62 (+7.9)
• Domain Modelling 100 → 100 (+0.0)
• Accessibility 41 → 42 (+0.7)

• Change coupling clique: HbaseMapAgentResponseTimeDao.java, HbaseMapInLinkDao.java, HbaseMapOutLinkDao.java (web/src/main/java/com/navercorp/pinpoint/web/applicationmap/dao/hbase/HbaseMapAgentResponseTimeDao.java)
• Change coupling: ChildTrace.java ↔ DefaultTrace.java (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/ChildTrace.java)
• Change coupling: DefaultTrace.java ↔ DisableTrace.java (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/DefaultTrace.java)
• Change coupling: OtlpTraceLinkMapper.java ↔ OtlpTraceSpanEventMapper.java (otlptrace/otlptrace-collector/src/main/java/com/navercorp/pinpoint/otlp/trace/collector/mapper/OtlpTraceLinkMapper.java)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (web-frontend/src/main/v3/yarn.lock)
• DefaultLinkFilter.filter (cognitive 34) (web/src/main/java/com/navercorp/pinpoint/web/applicationmap/dao/mapper/DefaultLinkFilter.java)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• DependencyResolver.combination (cognitive 20) (agent-module/plugins-test-module/plugins-test/src/main/java/com/navercorp/pinpoint/test/plugin/maven/DependencyResolver.java)
• Duplicated block (10 lines × 2) (agent-module/bootstraps/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/interceptor/AsyncContextSpanEventBlockApiIdAwareAroundInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/bootstraps/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/interceptor/AsyncContextSpanEventEndPointInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/bootstraps/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/plugin/jdbc/interceptor/CallableStatementRegisterOutParameterInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/bootstraps/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/util/spring/StringUtils.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/activemq-client/src/main/java/com/navercorp/pinpoint/plugin/activemq/client/interceptor/ActiveMQMessageConsumerDispatchInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/activemq-client/src/main/java/com/navercorp/pinpoint/plugin/activemq/client/interceptor/ActiveMQMessageConsumerDispatchInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/db2-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/db2/Db2Plugin.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/dbcp/src/main/java/com/navercorp/pinpoint/plugin/commons/dbcp/CommonsDbcpPlugin.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/elasticsearch/src/main/java/com/navercorp/pinpoint/plugin/elasticsearch/interceptor/ElasticsearchExecutorInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/httpclient3/src/main/java/com/navercorp/pinpoint/plugin/httpclient3/interceptor/HttpMethodBaseRequestAndResponseMethodInterceptor.java)
• Duplicated block (10 lines × 2) (agent-module/plugins/httpclient4/src/main/java/com/navercorp/pinpoint/plugin/httpclient4/interceptor/HttpRequestExecutorDoSendRequestAndDoReceiveResponseMethodInterceptor.java)
• …and 562 more

• ASMGuardedInterceptorFactory.findEligibleBaseInterface (cognitive 25) (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/instrument/ASMGuardedInterceptorFactory.java)
• ASMGuardedInterceptorFactory.findEligibleBaseInterface (cyclomatic 16) (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/instrument/ASMGuardedInterceptorFactory.java)
• AgentActiveChart.AgentActiveChart (cognitive 21) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveChart.tsx)
• AgentActiveChart.AgentActiveChart (cyclomatic 18) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveChart.tsx)
• AgentActiveTable.AgentActiveTable (cyclomatic 16) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveTable.tsx)
• AgentActiveThreadFetcher.AgentActiveThreadFetcher (cognitive 28) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveThreadFetcher.tsx)
• AgentActiveThreadFetcher.AgentActiveThreadFetcher (cyclomatic 19) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveThreadFetcher.tsx)
• AgentActiveThreadView.AgentActiveThreadView (cognitive 18) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveThreadView.tsx)
• AgentActiveThreadView.AgentActiveThreadView (cyclomatic 16) (web-frontend/src/main/v3/packages/ui/src/components/AgentActiveThread/AgentActiveThreadView.tsx)
• AgentListFetcher.AgentListFetcher (cognitive 17) (web-frontend/src/main/v3/packages/ui/src/components/Agent/AgentListFetcher.tsx)
• AgentListFetcher.AgentListFetcher (cyclomatic 18) (web-frontend/src/main/v3/packages/ui/src/components/Agent/AgentListFetcher.tsx)
• AgentStatisticTable.AgentStatisticTable (cognitive 20) (web-frontend/src/main/v3/packages/ui/src/components/Config/agentStatistic/AgentStatisticTable.tsx)
• AgentStatisticTable.AgentStatisticTable (cyclomatic 16) (web-frontend/src/main/v3/packages/ui/src/components/Config/agentStatistic/AgentStatisticTable.tsx)
• ApplicationCombinedListForCommon.ApplicationCombinedListForCommon (cognitive 81) (web-frontend/src/main/v3/packages/ui/src/components/Application/ApplicationCombinedListForCommon.tsx)
• ApplicationCombinedListForCommon.ApplicationCombinedListForCommon (cyclomatic 58) (web-frontend/src/main/v3/packages/ui/src/components/Application/ApplicationCombinedListForCommon.tsx)
• ApplicationMapBuilder.buildSpanStat (cognitive 32) (collector/src/main/java/com/navercorp/pinpoint/collector/applicationmap/model/ApplicationMapBuilder.java)
• BasicLoginService.getUserDetails (cognitive 21) (basic-login/src/main/java/com/navercorp/pinpoint/login/basic/service/BasicLoginService.java)
• CallTree.CallTree (cognitive 51) (web-frontend/src/main/v3/packages/ui/src/components/Transaction/call-tree/CallTree.tsx)
• CallTree.CallTree (cyclomatic 40) (web-frontend/src/main/v3/packages/ui/src/components/Transaction/call-tree/CallTree.tsx)
• Change coupling clique: ChildTrace.java, DefaultTrace.java, DisableChildTrace.java, DisableTrace.java (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/ChildTrace.java)
• …and 1333 more

• 256 commits — 241 feature/other, 15 fixes

• web-frontend/src — 93 commits
• otlptrace/otlptrace-collector — 25 commits
• agent-module/profiler — 24 commits
• collector/src — 15 commits
• agent-module/plugins-test-module — 14 commits
• agent-module/plugins — 12 commits
• web/src — 12 commits
• agent-module/plugins-it — 9 commits
• (root) — 7 commits
• alarm/src — 5 commits
• commons-server/src — 4 commits
• service-module/src — 4 commits
• agent-module/agent-testweb — 3 commits
• .github/workflows — 2 commits
• agent-module/agent — 2 commits
• alarm-batch/src — 2 commits
• basic-login/src — 2 commits
• batch/src — 2 commits
• commons/src — 2 commits
• pinot/pinot-kafka — 2 commits

• fix: [#14276] Fix NoSuchMethodError in the WebFlux and RestTemplate header adaptors on Spring Framework 7
• fix: [#14306] Fix uriStat summary ORDER BY for avgTimeMs and apdex
• fix: [#noissue] Fix ExceptionChainSampler failing on non-positive throughput
• fix: [#noissue] Fix heatmap crash when adjusting the visual map
• fix: [#noissue] Fix inverted namespace check in HbaseTestCluster and drop io.micrometer.common usages
• fix: [#noissue] Fix map help text that misdescribes the UI
• fix: [#noissue] Fix packages/ui build without changing what it emits
• fix: [#noissue] Fix server-map build by typing defaultTheme as it is actually built
• fix: [#noissue] Fix the build broken by stale package paths
• fix: [#noissue] Fix the commented compressionType key in the pinot kafka producer profiles
• fix: [#noissue] Fix the eslint errors surfaced by the widened lint scope
• fix: [#noissue] Fix the table checkbox nudge losing its target
• fix: [#noissue] Fix the unused React import that broke the ui package build
• fix: [#noissue] Revert "Index child-carried OTel links in FilteredMapBuilder"
• fix: [#noissue] Revert "Map OTel Span.Link on child spans in otlptrace collector"
• change: [#13857] Allow configured hosts to resolve into private webhook ranges
• change: [#13914] Handle unregistered service in collector
• change: [#14028] Drop ApplicationIndex(v2) enable properties from collector
• change: [#14028] Remove ApplicationTraceIndex(v1) from collector
• change: [#14103] Remove dead codes
• …and 236 more

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

pinpoint-apm/pinpoint 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.