Skip to content
CAI
Software that uses CAICheck a score

pinpoint-apm/pinpoint

46.7

Weak · 13 November 2026

442.8k

lines of production code

Java

with TypeScript

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add AWS SDK S3 client plugin

Introduces a new profiler plugin for the AWS SDK v2 S3 client, enabling automatic tracing of S3 operations. The plugin instruments the S3 client and its internal handlers to record service type, HTTP status codes, and error states, configurable via \profiler.aws.sdk.s3.enable\, \profiler.aws.sdk.s3.statuscode\, and \profiler.aws.sdk.s3.mark.error\.

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

Add AWS SDK S3 client plugin for distributed tracing

The agent now includes a new plugin that automatically instruments AWS SDK for Java S3 client calls. This adds distributed tracing for S3 operations, recording the HTTP URL, status code, and ETag in span attributes when configured. It also captures exceptions and error states, providing visibility into S3 request success and failure within the trace.

pinpoint-aws-sdk-s3-plugin · high confidence

Add ActiveMQ client tracing plugin

This change introduces a new plugin that enables distributed tracing for the ActiveMQ client library (versions 5.1.0 to 5.16). The plugin instruments the producer and consumer paths to propagate trace context via JMS message headers (TraceID, SpanID, ParentSpanID, Sampled, Flags, and application metadata). Users can enable or disable tracing for the client, producer, and consumer independently, and optionally capture the text content of received messages. The plugin also supports excluding specific destinations from tracing using a configurable path separator and exclusion list.

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

Add AgentEvent value object for web layer

The web module now includes a new AgentEvent value object that maps agent lifecycle events (such as start and shutdown) from the server backend to the web interface. This class exposes agent ID, timestamps, event type, and optional event messages, enabling the UI to display detailed agent lifecycle information.

pinpoint-web · high confidence

Add Apache CXF plugin for tracing and logging

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

Add Apache Pekko HTTP plugin

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

Add Apache Pulsar plugin for distributed tracing

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

Add CUBRID JDBC driver profiling support

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

Add Cassandra 4.x JDBC profiling plugin

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

Add Cassandra JDBC driver profiler plugin

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

Add Dameng JDBC driver plugin

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

Add Elasticsearch 8.x agent plugin

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

Add Fastjson plugin for JSON serialization/deserialization tracing

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

Add Hystrix plugin for Netflix Hystrix command and metrics tracing

This change introduces a new profiler plugin for Netflix Hystrix (versions 1.4 to 1.5), enabling distributed tracing for Hystrix commands, fallbacks, timeouts, and internal metrics. The plugin instruments \HystrixCommand\, \HystrixObservableCommand\, and related metrics classes to record execution spans, command keys, group keys, and fallback causes. Tracing is controlled by the \profiler.hystrix\ configuration flag (defaulting to disabled) and requires \profiler.rxjava=true\. Users will see Hystrix-related service types and annotations in their traces, providing visibility into circuit breaker states and command execution flows.

agent-module/plugins/hystrix, agent-module/plugins/jdk-completable-future, agent-module/plugins/thread · high confidence

Add Informix and Microsoft SQL Server JDBC plugins

The agent now includes new plugins for profiling Informix and Microsoft SQL Server JDBC connections. 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 interceptors to capture database activity.

(repo-wide) · high confidence

Add Jetty 12 plugin supporting EE10 and EE11

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

Add Ktor client and server tracing instrumentation

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

Add OpenTelemetry sample testwebs for Micronaut and Quarkus

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

Add OpenWhisk plugin for distributed tracing

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

Add ParameterRecorder for Pinot query parameter logging

A new ParameterRecorder class has been added to the Pinot datasource module to wrap Pinot prepared statements. This component intercepts parameter binding calls (such as setString, setInt, setBytes, etc.) and records them, enabling better visibility into the parameters sent to Pinot queries. The implementation uses Java's HexFormat for byte array encoding.

pinpoint-pinot-datasource · high confidence

Add Redis Lettuce client plugin for Pinpoint agent

Introduces a new profiler plugin for the Redis Lettuce client (versions 5.0.0.RELEASE to 5.1.2.RELEASE), enabling automatic tracing of Redis operations. The plugin records service type, endpoint details, and asynchronous context for Lettuce calls, and includes support for tracing Pub/Sub listeners via configurable base packages. Users can enable or disable the plugin and adjust Pub/Sub tracing settings using the \profiler.redis.lettuce.enable\ and \profiler.redis.lettuce.trace.pubsub-listener\ configuration properties.

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

Add Redisson client profiling plugin

Introduces a new profiler plugin for the Redisson Redis client (versions 3.10.0 to 3.10.4), enabling automatic tracing of synchronous, reactive, and Rx command executions. Users can enable this feature via the \profiler.redis.redisson.enable\ configuration flag and optionally track specific keys using \profiler.redis.redisson.keytrace\.

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

Add Spring Cloud Sleuth plugin for Project Reactor tracing

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

Add TagInformation record for inspector data

A new TagInformation record has been added to the inspector-commons module to structure inspector data. This record encapsulates application context (application name, agent ID), metric details (metric name, field name), and associated tags, providing a structured model for handling inspector data during operations such as alarm batch processing in Pinot.

pinpoint-inspector-commons · high confidence

Add Undertow Servlet plugin for async request tracing

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

Add Undertow Web Server plugin for Pinpoint agent

This change introduces a new profiler plugin for the Undertow web server (supporting versions 2.0.0.Final through 2.0.16.Final), enabling automatic tracing of HTTP requests in applications using Undertow, including Spring Boot and WildFly deployments. The plugin instruments the \Connectors.executeRootHandler\ method to capture request and response details, including query parameters, headers, and status codes. It provides configuration options to enable/disable tracing, hide Pinpoint-specific headers, exclude specific URLs or HTTP methods from profiling, and control real IP address detection via standard headers like X-Forwarded-For.

agent-module/plugins/undertow · high confidence

Add WebLogic application server plugin

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

Add circuit breaker subscriber tracing for Resilience4J

The Resilience4J plugin now includes a new interceptor that traces circuit breaker subscriber operations. This change enables the agent to record service type and API details for circuit breaker events, and optionally records exceptions when a circuit breaker is triggered, providing better visibility into resilience patterns in reactive applications.

pinpoint-resilience4j-plugin · high confidence

Add empty SMS sender implementation

The batch alarm sender module now includes an EmptySmsSender class that implements the SmsSender interface. This component provides a no-op implementation for sending SMS alerts, logging a message when invoked instead of transmitting actual SMS messages, which allows for graceful handling of SMS sending in environments where SMS functionality is not required or configured.

pinpoint-batch-alarmsender · high confidence

Add gRPC plugin test web application

A new test web application has been added to the agent-module to facilitate testing of the gRPC plugin. This includes a Spring Boot starter, a controller exposing endpoints for unary and streaming gRPC calls, and embedded gRPC server and client implementations. The application also includes the necessary Protocol Buffer definitions for the 'Greeter' and 'StreamingGreeter' services and is configured to run on port 18080 with Swagger UI enabled at the root path.

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

Add jTDS JDBC driver plugin for SQL Server profiling

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

Add profiling support for Apache Commons DBCP, DBCP2, and Druid connection pools

The agent now includes new profiler plugins for Apache Commons DBCP (versions 1.0–1.4), Commons DBCP2 (versions 2.0–2.9), and Alibaba Druid (versions 1.0–1.2). These plugins instrument the respective \BasicDataSource\ classes to trace connection acquisition (\getConnection\) and closure, and optionally monitor pool health metrics such as active and maximum connection counts. Users can enable these features via \pinpoint.config\ using \profiler.jdbc.dbcp\, \profiler.jdbc.dbcp2\, and \profiler.jdbc.druid\ settings, with an additional \connectionclose\ option to profile the closing of pooled connections.

(repo-wide) · high confidence

Add proxy request parsing for Apache, Nginx, App, and User-defined proxies

The agent now includes new proxy plugins that parse specific HTTP headers to capture upstream proxy metadata. Apache, Nginx, and App plugins parse headers named Pinpoint-ProxyApache, Pinpoint-ProxyNginx, and Pinpoint-ProxyApp respectively, extracting timing and status data. A User plugin allows custom header names via configuration to parse similar data. This enables the agent to record detailed proxy request information in traces.

(repo-wide) · high confidence

Add web-layer support for OpenTelemetry metric definitions and data queries

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

Added JDK 8 profiler support for IBM Java and lambda bytecode instrumentation

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

Added MapStruct SPI support for Protobuf accessor naming

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

Added MySQL data access layer for feature flags

Introduced the database persistence components for the feature flag system, including the MysqlFeatureFlagDao implementation and supporting value objects (FeatureFlagParameter, FeatureFlagResult). This enables the application to query feature flag configurations from a MySQL database using MyBatis, supporting lookups by feature name and rule type (ENABLED/DISABLED) and matching results against specific service and application names.

pinpoint-feature-flag · high confidence

Added MySQL implementation for user group and member management

The user module now includes a new MySQL-specific data access object (MysqlUserGroupDao) that implements the UserGroupDao interface. This component enables the system to manage user groups and their members by providing methods to create, update, and delete groups, as well as to add, remove, and query group members and their contact information (phone numbers and emails). This change supports the underlying infrastructure for group-based user management within the Pinpoint user service.

pinpoint-user · high confidence

Added Pinot alarm DAO implementation and value object

The pinot-batch module now includes a new MySQL-based data access implementation for Pinot alarms. This change introduces the \PinotAlarmDaoImpl\ class, which handles database operations for retrieving alarm keys and rules, as well as inserting alarm history records via MyBatis. It also adds the \PinotAlarmKey\ value object, which defines the structure for identifying specific alarms by service, application, target, and category.

pinpoint-pinot-batch · high confidence

Added ProfilerDescription value object

A new ProfilerDescription class has been introduced in the realtime-common module to wrap a ClusterKey. This object provides serialization and deserialization capabilities, allowing profiler descriptions to be converted to and from a colon-separated string format (applicationName:agentId:ip:port), which facilitates the handling of profiler identification data within the realtime system.

pinpoint-realtime-common · high confidence

Added Pulsar plugin test web application

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

Added Tags model for metric data serialization

The \Tags\ class has been introduced in the metric-commons module to handle collections of key-value tags for metric data. This model supports Jackson serialization via a custom \TagSerializer\ and allows dynamic addition of tag entries, providing the underlying data structure required for agent statistical data tables.

pinpoint-metric-commons · high confidence

Added interceptors for Spring Reactive and Aspect-based transaction tracing

The Spring TX plugin now includes dedicated interceptors for tracing reactive transaction support and standard transaction aspect support. The new ReactiveTransactionSupportInterceptor handles async context propagation for reactive results, while the TransactionAspectSupportInterceptor manages exception marking and API recording for standard transactional methods, ensuring consistent transaction span coverage for both reactive and synchronous Spring transaction patterns.

pinpoint-spring-tx-plugin · high confidence

Added interface stability and visibility annotations

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

Added request parameter extraction for WebLogic and WebSphere plugins

New parameter extractor classes have been added for the WebLogic and WebSphere application server plugins. The \ServletRequestImplParameterExtractor\ for WebLogic and the \IRequestParameterExtractor\ for WebSphere now parse and abbreviate HTTP request query parameters, applying configurable limits on individual parameter length and total output size to prevent excessive data capture in traces.

pinpoint-weblogic-plugin, pinpoint-websphere-plugin · high confidence

Agent module documentation and testweb scaffolding consolidated

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

Bootstrap core adds instrumentation utilities and async tracing interceptors

The pinpoint-bootstrap-core module introduces several new capabilities for agent instrumentation. It adds a suite of matcher operands (Annotation, Class, Interface, Package, and SuperClass) to support more granular class matching, alongside utility classes for class loading (LauncherBootLoader) and filtering (ClassFilters, MethodFilters). For JDBC plugins, it provides new bind-variable filters (IncludeBindVariableFilter, ExcludeBindVariableFilter) and a PreparedStatementBindingMethodFilter to better control which SQL binding methods are intercepted. Additionally, it introduces new abstract interceptors (AsyncContextSpanEventNestedApiIdAwareAroundInterceptor and InjectedAsyncContextSpanEventNestedApiIdAwareAroundInterceptor) to handle nested async trace scopes, and a LoggingInterceptor for debugging.

pinpoint-bootstrap-core · high confidence

Collector now sends metric data including tenantId and supports Telegraf ingestion

The metric collector has been updated to include the tenantId in all metric data sent to Kafka, enabling proper multi-tenant isolation. Additionally, new data models (TelegrafMetric, TelegrafMetrics) and DAOs (PinotMetricTagDao, PinotSystemMetricDataTypeDao, PinotSystemMetricDoubleDao) have been introduced to support ingesting Telegraf-format metrics and managing metric tags and system metrics in Pinot, with Kafka keys and topics configured for system metric double tables.

pinpoint-metric · high confidence

Configure JUnit 5 Test Engine and Logging for Plugin Tests

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

Elasticsearch plugin interceptors added for executor and client methods

The Elasticsearch agent plugins now include new interceptors to capture detailed execution attributes. The \ElasticsearchExecutorInterceptor\ (for Elasticsearch 7.x) and \ElasticsearchClientMethodInterceptor\ (for Elasticsearch 8.x) record the Elasticsearch version, cluster name, and the DSL query string (abbreviated to 256 characters) for search, get, index, delete, and update operations, provided the corresponding configuration options are enabled.

pinpoint-elasticsearch-plugin, pinpoint-elasticsearch8-plugin · high confidence

Enable agent statistics collection via Pinot and Kafka

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

Exception log records are now selected and deduplicated for Error Analysis

The OTLP log collector now identifies exception LogRecords by the presence of 'exception.\*' attributes and feeds them into Error Analysis. To prevent duplicate entries caused by instrumentation and appender logging, a per-request deduplicator keeps the record with the most complete stack trace. Users can also configure scope and application name prefixes to blacklist noise via the 'pinpoint.collector.otlplog.filter.blacklist' properties.

pinpoint-otlplog-collector · high confidence

Initial repository scaffolding and documentation

The repository is initialized with essential project documentation and configuration files, including a comprehensive README.md detailing the Pinpoint APM system, its supported modules, and compatibility tables for Java, HBase, Pinot, and agent-collector versions. A new AGENTS.md file provides architectural guidance and coding standards for AI agents, while BUILD.md and CONTRIBUTING.md offer instructions for building the project and submitting contributions. The project also includes standard legal files (LICENSE, NOTICE), a .gitignore for build artifacts and IDE files, a .gitmodules entry for the grpc-idl submodule, and the Apache Maven Wrapper (mvnw) to ensure consistent build environments.

(repo-wide) · high confidence

Introduce HBase Schema Manager for schema lifecycle management

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

Introduce HBase schema management capabilities

This change adds the HBase schema manager component, introducing new classes to handle schema operations and user interaction. The XmlFormatter component enables pretty-printing of XML content for schema definitions. A read-only wrapper for the schema change log DAO is added to safely manage table existence checks and log insertions without modifying underlying data. Additionally, a HelpTask is introduced to provide users with detailed usage instructions and command options (such as init, update, reset, summary, and log) for managing the HBase schema via the command line.

pinpoint-hbase-schema-manager · high confidence

Introduce Pinot datasource module with async query support

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

Introduce Spring Boot-based collector with ServerMap V3 support

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

Introduce common model and view classes for OpenTelemetry metric definitions and data

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

Introduce commons-config module for annotation-based property injection

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

Introduce exception trace data model and Pinot storage configuration

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

Introduce gRPC transport layer with V4 protocol support

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

Introduce new Inspector Web module for agent and application statistics

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

Introduce new plugin test execution engine and infrastructure

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

Introduce new system metric collector module with Pinot and Kafka integration

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

Introduce new timeseries-commons library with core time-series data models

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

Introduce property-based feature flag support with application-level enable/disable rules

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Feature flags now support service-scoped targeting.

feature-flag · low confidence · unverified

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

Introduce standalone OTLP trace collector with admission control and HTTP/JSON support

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

Introduce timeseries module with time primitives and windowing utilities

The pinpoint-commons-timeseries module now provides core time-handling classes for time-series data. This includes a Timestamp type supporting ISO 8601 and epoch milliseconds, a Range class for time intervals, and a TimeWindow class for dividing time ranges into slots. Additionally, it adds range splitters (BackwardRangeSplitter, EvenRangeSplitter) and a ForwardRangeValidator to manage and validate time ranges, along with a TimeSeriesVirtualList for efficient iteration over time series data.

pinpoint-commons-timeseries · high confidence

Introduce web-layer API for alarm channels, catalog, and configuration validation

The alarm-web module now exposes REST endpoints for managing notification channels (CRUD and rule/channel linking), browsing available data sources and metric presets, and validating alarm rule configurations. This includes a new \AlarmCatalogController\ for discovering data sources and template presets, an \AlarmChannelController\ for service-level channel management and rule-channel bindings, and an \AlarmConfigValidator\ that enforces data source category alignment, interval rounding, and condition limits for both standalone rules and template items. Ownership checks and bundle-lock ordering are enforced to prevent deadlocks and ensure channels and rules are only modified by their owning services. Also in this area: 1 commit (0 fixes) modifying alarm/alarm-common, alarm/alarm-web.

alarm/alarm-web · medium confidence · unverified

Introduces PinpointWebStarter with Spring Boot Actuator and OpenTelemetry support

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

Introduces chain pattern for MyBatis registry handlers

The pinpoint-commons-mybatis module now includes a MyBatisRegistryHandlerChain class that allows multiple MyBatisRegistryHandler instances to be executed sequentially. This enables users to register multiple type aliases and type handlers in a single, ordered operation, simplifying the composition of registry configurations.

pinpoint-commons-mybatis · high confidence

Introduces configurable HBase schema loading via XML reader

A new XmlHbaseSchemaReader component has been added to the pinpoint-hbase-schema module, enabling the system to load HBase schema change sets from an XML file. This reader supports a configurable schema path (defaulting to classpath:hbase-schema/hbase-schema.xml) and handles both absolute and relative resource locations, allowing users to define custom schema locations rather than relying on a hardcoded path.

pinpoint-hbase-schema · high confidence

Introduces gRPC header versions and client/server interceptors for enhanced connection and stream management

The pinpoint-grpc module now supports two header formats, HeaderV1 and HeaderV4, with the latter introducing an optional apiKey and a dedicated serviceName field. To support these headers, new server-side readers (ServerHeaderReaderV1 and ServerHeaderReaderV4) have been added to parse incoming metadata. On the client side, new interceptors manage connection and stream lifecycle: SocketIdClientInterceptor assigns unique socket IDs, SupportCommandCodeClientInterceptor advertises supported command codes, and UnaryCallDeadlineInterceptor enforces timeouts on unary calls. On the server side, the system now tracks active connections via ConnectionCountServerTransportFilter and monitors active streams with StreamCountInterceptor. Additionally, TransportMetadataServerInterceptor binds transport metadata to the gRPC context, and a custom PinpointDnsNameResolverProvider is provided for DNS resolution.

pinpoint-grpc · high confidence

Introduces log protocol configuration and data models for log streaming

This change adds the foundational configuration and data structures for the log service protocol within log-common. It introduces LogServiceProtocolConfig to define the Spring beans for the log channel protocol, wiring Redis Pub/Sub for demands and Redis Streams for supplies with specific buffer and interval settings. Additionally, it adds new Value Objects and DTOs including LogDemand, LogSupply, LogPile, LogFileList, and FileKey to represent log requests, responses, and file metadata, along with a unit test for the FileKey parsing logic.

log/log-common · high confidence

Introduces new server-side business objects and trace serialization components

The pinpoint-commons-server module adds several new data structures and serialization utilities to support trace processing and metadata handling. This includes new business objects for agent information (AgentInfoBo, JvmInfoBo, ServerMetaDataBo, ServiceInfoBo), parent application context (ParentApplication), and exception details (ExceptionInfo). Additionally, it introduces a new per-type encoder interface in AnnotationTranscoder, a filter for sequence validation (SequenceSpanEventFilter), and a suite of v2 trace serializers and decoders (SpanDecoderV0, TraceRowKeyDecoderV2) along with metadata row key decoders, enabling updated trace format handling and more efficient data encoding on the server side.

pinpoint-commons-server · high confidence

Introduction of new commons module with core tracing infrastructure

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

Java 9+ module system support for Pinpoint agent

The Pinpoint agent now includes a bootstrap module for Java 9 and later that enables runtime manipulation of the Java Platform Module System (JPMS). This change introduces classes to analyze JAR files for service provider configurations and packages, and provides a JavaModule implementation that allows the agent to dynamically add reads, exports, opens, uses, and provides relationships between modules at runtime. This capability is essential for the agent to instrument and interact with modularized Java applications.

pinpoint-bootstrap-java9 · high confidence

Java 9+ module system support for the agent bootstrap

The bootstrap module now includes a new Java 9+ classloader and module support layer to handle Java Platform Module System (JPMS) requirements. This introduces a custom classloader that properly delegates class and resource loading across module layers, and a module support system that dynamically defines the agent as a named module, configuring necessary exports, opens, and reads permissions for internal packages and external dependencies like Log4j and Guice. This ensures the agent can operate correctly on Java 9 and later versions where module boundaries restrict access to internal APIs.

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

MyBatis configuration and binding log plugin introduced

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

New Agent SDK async tracing plugin

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

New Apache HttpClient 4.x plugin for Pinpoint agent

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

New Apache HttpClient 5.x plugin for distributed tracing

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

New Apache Thrift plugin for client and server tracing

This change introduces a new Apache Thrift plugin that enables distributed tracing for both Thrift clients and servers. The plugin supports synchronous and asynchronous calls, allowing users to configure tracing via \pinpoint.config\ options such as \profiler.thrift.client\, \profiler.thrift.processor\, and flags to record arguments and results. It defines specific service types (THRIFT\_CLIENT, THRIFT\_SERVER, etc.) and annotation keys (URL, args, result) to capture trace data, and includes interceptors to handle client send/receive operations and server entry points.

agent-module/plugins/thrift · high confidence

New Arcus and Memcached profiling plugin

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

New AsyncHttpClient plugin for Pinpoint agent

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

New ClickHouse JDBC plugin for database tracing

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

New Exception Trace web module for querying Pinot exception data

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

New HBase schema management module

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

New HbaseTestCluster utility for integration testing

Added the HbaseTestCluster class in the pinpoint-hbase-testcluster module to provide a managed wrapper around the HBase testing cluster. This utility simplifies integration tests by handling cluster lifecycle management (start/stop) and offering helper methods to create namespaces and tables, ensuring a consistent test environment for HBase-related components.

pinpoint-hbase-testcluster · high confidence

New JBoss application server plugin for Pinpoint agent

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

New JDBC integration test utilities module

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

New JDK HTTP plugin test web application with SSL and HTTP/2 support

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

New JDK HttpURLConnection Profiler Plugin

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

New Jetty plugin supporting versions 8.0 through 11.x

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

New Log4j and Logback plugins for automatic transaction ID injection

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

New Log4j2 plugin for automatic transaction ID injection and log pattern replacement

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

New Micrometer-based metrics collection module

A new micrometer module has been introduced to enable OpenTelemetry Protocol (OTLP) metrics collection. This change adds a dedicated \AgentOtlpMeterRegistry\ that automatically binds standard JVM metrics (such as memory, GC, threads, and classloader stats) and system metrics (including disk space, file descriptors, and processor usage) to the registry. The \DefaultMicrometerMonitor\ component integrates this registry, injecting the Pinpoint service, application, and agent identifiers to tag the exported metrics, and respects the \MicrometerConfig\ to enable or disable the feature.

pinpoint-profiler-micrometer · high confidence

New MySQL JDBC plugin test web application

A new test web application has been added to the mysql-jdbc-plugin-testweb module to validate the MySQL JDBC plugin. It includes a Spring Boot controller that exercises standard JDBC operations (statements, prepared statements), stored procedures with IN/OUT and INOUT parameters, and the MySQL X DevAPI. The test environment is configured to run on port 18080, connects to a MySQL 8.0.36 instance via Testcontainers, and uses the mysql-connector-j 9.x driver.

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

New Netty profiler plugin for tracing HTTP client requests and channel events

A new Netty profiler plugin has been added to the agent, enabling automatic tracing of Netty-based HTTP client requests and channel lifecycle events. The plugin instruments \Bootstrap.connect\ to record destination endpoints, intercepts \ChannelPipeline.write\ and \writeAndFlush\ to capture asynchronous context propagation, and tracks channel closure. When HTTP codec tracing is enabled, it instruments \HttpObjectEncoder\ and \DefaultHttpRequest\ to record HTTP headers, URIs, and service types (NETTY, NETTY\_INTERNAL, NETTY\_HTTP). Configuration is controlled via \profiler.netty\ (to enable/disable the plugin) and \profiler.netty.http\ (to enable HTTP codec tracing), with additional options for parameter recording and channel close tracing.

agent-module/plugins/vertx · high confidence

New OpenTelemetry OTLP metric collector module

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

New Pinot Kafka module with configurable producer settings

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

New Pinot datasource and tenant configuration module

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

New Reactor Netty plugin for HTTP server and client tracing

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

New Redis Jedis plugin for Pinpoint agent

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

New Redis Pub/Sub-based channel protocol for ATC, ATD, and Echo services

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

New Redis-based channel and value incrementer implementations

This update introduces new Redis-backed implementations for the Pinpoint channel and value incrementer modules. Specifically, it adds PubChannel and SubChannel implementations for Redis Key-Value (using RedisTemplate), Pub/Sub (using ReactiveRedisTemplate), and Streams (using ReactiveStreamOperations and StreamMessageListenerContainer), enabling data transport via these Redis mechanisms. Additionally, a new RedisIncrementer is provided to generate unique identifiers using Redis atomic increments, falling back to System.nanoTime() if the key does not exist.

pinpoint-redis · high confidence

New Redis-based channel providers for key-value, pub/sub, and stream messaging

This change introduces three new Redis channel implementations for Pinpoint's real-time data pipeline: a key-value channel (scheme 'kv') that polls Redis keys on a configurable interval, a pub/sub channel (scheme 'pubsub') using Redis native publish/subscribe, and a stream channel (scheme 'stream') leveraging Redis Streams. Each is provided via dedicated Spring configurations (RedisKVChannelConfig, RedisPubSubConfig, RedisStreamConfig) that register their respective ChannelProvider implementations. The underlying Redis connection is standardized through a new RedisBasicConfig using the Lettuce client, with native kqueue transport explicitly disabled to avoid known issues. Property sources are separated into root and profile-specific files for easier configuration management.

redis · high confidence

New Spring Boot application detection and tracing plugin

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

New Spring Data R2DBC plugin for reactive database tracing

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

New Spring Data R2DBC plugin testweb module for multi-database validation

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

New Tomcat plugin for application performance monitoring

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

New URI statistics web module with chart and summary APIs

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

New User Plugin for custom profiling entry points

The agent now includes a new 'User' plugin that allows users to define custom classes and methods for profiling via the \profiler.include\ and \profiler.entrypoint\ configuration properties. This plugin introduces interceptors to trace these user-defined entry points, including specific support for message queue client handlers (e.g., Spring JMS, RabbitMQ) to ensure async context is correctly carried across trace blocks. It also registers a \TraceMetadataProvider\ and provides a standalone trace scope for methods not already part of an existing trace.

agent-module/plugins/user · high confidence

New Vert.x plugin for HTTP server and client tracing

The Pinpoint agent now includes a new plugin for the Vert.x framework, enabling automatic distributed tracing for Vert.x HTTP servers and clients. This addition introduces interceptors to capture HTTP status codes, record request parameters with size limits, and manage async context propagation across Vert.x handlers and internal HTTP components, allowing users to monitor and debug Vert.x-based applications.

pinpoint-vertx-plugin · high confidence

New agent network availability checker tool

A new standalone tool has been added to the agent module to verify network connectivity for gRPC-based agent communication. The \NetworkAvailabilityChecker\ utility reads the agent configuration file and performs TCP connectivity checks against the agent, metadata, stat, and span collector endpoints. It includes supporting classes for network checking logic, gRPC transport configuration resolution, and property resolution, along with a shell script (\networktest.sh\) to execute the checks, allowing users to validate their agent's network setup before deployment.

agent-module/agent-tools · high confidence

New agent test web modules for SDK async and thread plugin verification

This change introduces three new Spring Boot-based test web applications within the agent-testweb module to support agent plugin testing. The SDK async testweb provides endpoints to verify thread context propagation using the Pinpoint SDK's TraceExecutors and TraceRunnable/TraceCallable wrappers, covering manual wrapping, automatic wrapping, and async entry points. The closed-module testweb demonstrates tracing across Java module boundaries by calling a service from a separate module. The thread plugin testweb exposes endpoints to test tracing for standard Java concurrency patterns, including CompletableFuture supplyAsync/runAsync, direct executor service execution, and Spring's @Async annotation.

(repo-wide) · high confidence

New automatic and offset-aware buffer implementations with string caching

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

New batch infrastructure and datasource alarm capabilities

This update introduces new components within the batch module to support enhanced alarm processing and job orchestration. It adds a new \AgentChecker\ base class and \AppAlarmChecker\ to manage alarm rules per application, alongside a \DataSourceDataCollector\ that queries Pinot for database connection usage metrics (active vs. max connections) to trigger alarms. Additionally, it provides \JobLaunchSupport\ and \StartupJobLauncher\ to facilitate the execution of batch jobs at startup, and a \MysqlAlarmDao\ for persisting alarm checker results.

pinpoint-batch · high confidence

New batch job for URI statistics-based alarms

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

New channel module for unified message transport and service communication

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

channel, pinpoint-channel · low confidence

New collector-monitor module for HBase and thread-pool metrics

The collector now includes a dedicated monitoring module that exposes HBase client-side metrics (counters, timers, gauges, histograms) and thread-pool execution statistics (submitted, running, completed, rejected tasks) via Micrometer. HBase metrics are collected through a configuration class that reflects into HBase connection objects to extract their internal MetricRegistry, while thread-pool metrics are gathered by wrapping executors with a monitored factory that chains logging and counter-based rejection handlers. Network and Netty allocator metrics are also bound to the registry, and gRPC interceptors tag metrics by service (agent, span, stat).

collector-monitor · high confidence

New collector-monitor module with network metrics and execution utilities

The collector-monitor module has been introduced, adding a new \NetworkMetricsBinder\ that exposes system network statistics (bytes and packets sent/received) and open socket counts via Micrometer, alongside utility classes \BypassRunnableDecorator\ and \RejectedExecutionHandlerChain\ for managing thread pool execution behavior.

pinpoint-collector-monitor · high confidence

New commons-server configuration and domain model components

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

New concurrency, logging, and clock utilities in commons-profiler

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

New exception trace collector module for Pinot ingestion

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

New gRPC client and server tracing plugin

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

New hbase-testcluster module for in-process HBase integration testing

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 the HBase MiniCluster (HBase + HDFS + ZooKeeper) and exposes it as Spring beans (hbaseTestCluster, hbaseConfiguration, hbaseConnection, hbaseAsyncConnection) via HbaseTestClusterConfiguration, enabling developers to run integration tests against a local, ephemeral HBase instance.

hbase-testcluster · high confidence

New integration test utilities for Docker, HTTP, and logging

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

New log collector module with gRPC and Redis streaming support

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

New log live-tail feature with WebSocket and SSE endpoints

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

New log value objects for structured log identification

Added three new value objects in the log-common module to support structured log handling: HostKey and FileKey records for identifying log sources and files via host group/name and file paths, and a Log class containing sequence, timestamp, and content fields with Jackson serialization support. These classes provide the foundational data structures for the new live tail endpoints and log features referenced in the commit history.

pinpoint-log-common · high confidence

New metadata model for OTLP metrics in Pinot collector

The Pinot OTLP metric collector now uses a dedicated record, PinotOtlpMetricMetadata, to structure incoming metric data. This model captures essential attributes such as service and application names, agent identifiers, metric group and field names, units, descriptions, and aggregation details, ensuring that required fields are validated upon creation.

pinpoint-otlpmetric-collector · high confidence

New metric model classes and tag serialization infrastructure

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

New network diagnostics and OpenTelemetry metrics support

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

New plugin loader service interfaces and implementations

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

New plugins for Jackson JSON and Process Builder tracing

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

New profiling infrastructure components and utilities

This release introduces several new classes within the commons-profiler module to support profiling operations. A new millisecond-precision Clock interface is added, providing system, fixed, and tick-based clock implementations for time tracking. New consumer executors (EmptyConsumer and SingleConsumer) are introduced to handle data processing, alongside a LoggingDataSender for outputting data via logging. The module also includes a DefaultSqlNormalizer for parsing and normalizing SQL queries, a StaticFieldLookUp utility for inspecting static fields via reflection, and a deprecated CountLogThrottle for controlling log emission rates based on call counts.

pinpoint-commons-profiler · high confidence

New quickstart test application for Pinpoint instrumentation

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

New service-module for service registry and web parameter resolution

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

New trace metadata and caching utilities in pinpoint-commons

This change introduces several new components in the pinpoint-commons module to support trace metadata handling and caching. It adds a new LRU cache implementation (LRUCache) for managing cached data with a configurable maximum size. It also introduces a new base histogram schema (BaseHistogramSchema) that defines how histogram slots are organized for success and failure cases, including support for sum and max statistics. Additionally, a new bitmask-based ErrorCategorySet is added for efficient error categorization, and a new ParsedTraceMetadataProvider is introduced to facilitate the setup of trace metadata by registering service types and annotation keys. Finally, utility matchers for annotation keys (AnnotationKeyMatchers) are provided to support flexible matching logic.

pinpoint-commons · high confidence

New tracing plugins for Google HTTP Client and Apache HttpClient 3.x

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

New v3 web application shell with React-based layout and routing

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

Pinot-based data access for URI stat alarm jobs

The batch module now includes a new DAO implementation, PinotUriStatDao, which retrieves URI statistics (total count, failure count, Apdex, average response time, max response time, and key existence) from Pinot via MyBatis. This component provides the underlying data access layer required by the new alarm jobs added to the batch process for URI stat data.

pinpoint-uristat-batch · high confidence

Quickstart now includes a Maven Wrapper for simplified setup

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

RabbitMQ client plugin adds support for tracing custom consumers and Spring AMQP

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

Reactor Netty plugin adds interceptors for HTTP status codes, transport errors, and request parameters

The Reactor Netty plugin introduces new interceptors to enhance observability: ChannelOperationsInterceptor now records HTTP server response status codes; ClientTransportSubscriberInterceptor and HttpObserverOnUncaughtExceptionInterceptor capture transport and HTTP errors respectively when enabled via configuration; and HttpServerParameterExtractor extracts and abbreviates query parameters for trace context.

pinpoint-reactor-netty-plugin · high confidence

Receive OTLP exception logs in the trace collector and feed Error Analysis

The trace collector now ingests OTLP logs via gRPC and HTTP (POST /v1/logs) when the new otlplog module is enabled. It filters for LogRecords carrying exception attributes, maps them to the same ExceptionMetaDataBo format used by span events, and stores them in the Error Analysis table. The receiver uses its own admission budgets and worker pool to isolate back-pressure from the trace path, and reports drop reasons (e.g., no exception attributes, service not found, unsampled context) via metrics and OTLP partial-success responses.

otlplog/otlplog-collector · high confidence

Support for JDK 9+ class loading and shutdown hooks

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

Support for Pinot inspector data sorting and tag parsing

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

UriStat data is now published to Kafka via PinotUriStatDao

The uristat-collector module now includes a new PinotUriStatDao that sends URI statistics to a Kafka topic. This DAO uses Spring Kafka to asynchronously publish UriStat objects, with built-in logging for send results and validation for the Kafka template and topic configuration.

pinpoint-uristat-collector · high confidence

Webhook module separated and exposed via REST API

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

Architecture

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

Batch module restructured with Spring Boot and Java-based configuration

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

Extracted commons-hbase module with HBase 2 API support

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

Introduce Spring Boot Actuator and modularized web configuration

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

Introduce shared alarm data access layer and configuration

The alarm module has been split into a dedicated \alarm-common\ library that centralizes the core alarm data sources. This change introduces a shared \AlarmDaoConfigurationSupport\ class to standardize MyBatis DAO bean registration (including \AlarmRuleV2Dao\, \AlarmHistoryV2Dao\, and \AlarmNotificationChannelDao\) across all deployable services. It also adds the underlying DAO interfaces, implementations, and entity mappers required to persist and query alarm rules, templates, and notification channels, ensuring consistent data access and simplifying configuration for new alarm features. Also in this area: 1 commit (0 fixes) modifying alarm/alarm-common, alarm/alarm-web; 2 commits adding/updating tests in alarm/alarm-common; 2 commits (0 fixes) modifying alarm/alarm-common.

alarm/alarm-common · medium confidence · unverified

Refactored bootstrap core with new classloader and async context infrastructure

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

Behavioural changes

1 commit (0 fixes) modifying otlptrace/otlptrace-inspector, pinpoint-otlptrace-inspector

A change to existing behaviour in otlptrace/otlptrace-inspector, pinpoint-otlptrace-inspector — 1 commit, 40 files: “\[\#14596\] Store OTLP metrics as Inspector agent stat in OTLPTRACE” (refs \#14596).

otlptrace/otlptrace-inspector, pinpoint-otlptrace-inspector · medium confidence · unverified

10 commits (0 fixes) modifying alarm/alarm-core

A change to existing behaviour in alarm/alarm-core — 10 commits, 30 files: “\[\#14282\] Add the core alarm data sources”; “\[\#14282\] Carry the service of the rule in the alarm detail link”; “\[\#14327\] Set an explicit LIMIT on the agent stat alarm queries”; and 7 more (refs \#14282, \#14327, \#14590, \#14589).

alarm/alarm-core · medium confidence · unverified

12 commits (0 fixes) modifying pinpoint-alarm-common

A change to existing behaviour in pinpoint-alarm-common — 12 commits, 8 files: “\[\#14282\] Add the core alarm data sources”; “\[\#14282\] Carry the service of the rule in the alarm detail link”; “\[\#14638\] Add the detail link and the history link to the default webhook message”; and 9 more (refs \#14282, \#14638, \#14590, \#14589, \#14628, …).

pinpoint-alarm-common · medium confidence · unverified

16 commits (0 fixes) modifying alarm/alarm-batch

A change to existing behaviour in alarm/alarm-batch — 16 commits, 18 files: “\[\#14341\] Write the alarm timestamps in UTC”; “\[\#14282\] Add the core alarm data sources”; “\[\#14282\] Carry the service of the rule in the alarm detail link”; and 13 more (refs \#14341, \#14282, \#14534, \#14589, \#14590).

alarm/alarm-batch · medium confidence · unverified

2 commits (0 fixes) modifying agent-module/agent/src/main/resources/lib

A change to existing behaviour in agent-module/agent/src/main/resources/lib — 2 commits, 1 file: “\[\#10757\] Integrate agent module into a single module”; “\[\#11816\] Remove noLookups warning log from Log4j2” (refs \#10757, \#11816).

agent-module/agent/src/main/resources/lib · medium confidence · unverified

2 commits (0 fixes) modifying agent-module/plugins/pekko-http

A change to existing behaviour in agent-module/plugins/pekko-http — 2 commits, 17 files: “\[\#13818\] Add Apache Pekko HTTP plugin”; “\[\#noissue\] Update the plugin supported-version table for 4.0.0” (refs \#13818).

agent-module/plugins/pekko-http · medium confidence · unverified

4 commits (0 fixes) modifying alarm-batch-starter

A change to existing behaviour in alarm-batch-starter — 4 commits, 25 files: “\[\#14282\] Add a deployable that runs only the alarm job”; “\[\#14589\] Migrate server modules from Jackson 2 to Jackson 3”; “\[\#14282\] Reject an alarm rule the application it names cannot carry”; and 1 more (refs \#14282, \#14589).

alarm-batch-starter · medium confidence · unverified

4 commits (0 fixes) modifying applicationmap

A change to existing behaviour in applicationmap — 4 commits, 51 files: “\[\#14589\] Migrate server modules from Jackson 2 to Jackson 3”; “\[\#noissue\] Move the application map data access into its own module”; “\[\#noissue\] Replace Service.DEFAULT with the resolved service”; and 1 more (refs \#14589).

applicationmap · medium confidence · unverified

7 commits (0 fixes) modifying agent-module/plugins/kotlin-coroutines/src/main

A change to existing behaviour in agent-module/plugins/kotlin-coroutines/src/main — 7 commits, 13 files: “\[\#14391\] Carry the AsyncContext from before() to after() in the trace block of the async interceptor bases”; “\[\#14044\] Keep coroutine resume trace blocks balanced”; “\[\#10852\] Rename PLogger to PluginLogger”; and 4 more (refs \#14391, \#14044, \#10852, \#10757, \#12771, …).

agent-module/plugins/kotlin-coroutines/src/main · medium confidence · unverified

8 commits (0 fixes) modifying pinpoint-otlptrace-linkindex

A change to existing behaviour in pinpoint-otlptrace-linkindex — 8 commits, 15 files: “\[\#noissue\] Record when the slot quota fills, ignore stale slot summaries and log a changed flooder at once”; “\[\#noissue\] Add trace-sampled probes, remove stored SERVER identifiers when they are off and rename the SERVER rule prefix”; “\[\#noissue\] Give the link index quota back when the queue is full, pool the untracked identifiers and publish the slot summary off the ingest thread”; and 5 more (refs \#14453).

pinpoint-otlptrace-linkindex · medium confidence · unverified

9 commits (0 fixes) modifying otlptrace/otlptrace-linkindex

A change to existing behaviour in otlptrace/otlptrace-linkindex — 9 commits, 29 files: “\[\#noissue\] Record when the slot quota fills, ignore stale slot summaries and log a changed flooder at once”; “\[\#noissue\] Add trace-sampled probes, remove stored SERVER identifiers when they are off and rename the SERVER rule prefix”; “\[\#noissue\] Give the link index quota back when the queue is full, pool the untracked identifiers and publish the slot summary off the ingest thread”; and 6 more (refs \#14453).

otlptrace/otlptrace-linkindex · medium confidence · unverified

Add Java-based configuration and DAO layer for Pinot alarm jobs

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

Added Spring HTTP stub interfaces for compatibility

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

Agent configuration and logging infrastructure updates

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

Application map data access refactored and Apdex scores added to service group nodes

The application map module has been restructured to improve data access and visualization. Data access logic has been moved into a dedicated module, introducing new v3 DAO components (such as ResponseTimeV3ResultExtractor and specific row key decoders) to handle raw data retrieval more cleanly. Additionally, service group nodes in the application map now display an aggregated Apdex score, calculated by merging satisfaction and tolerating counts from underlying histograms to provide a unified performance metric for the group.

pinpoint-applicationmap · high confidence

Application map storage refactored to use UID-based row keys and dual-write support

The collector's application map storage has been updated to use service UIDs instead of application names in HBase row keys, improving data consistency and query performance. New V3 factory classes (InLinkFactoryV3, OutLinkFactoryV3, SelfAgentNodeFactoryV3) generate UID-based keys for links and nodes. A new HostApplicationMapDaoDelegate enables dual-write support, allowing the system to write to multiple DAO implementations simultaneously for reliability. Additionally, a new CollectorHbaseModule centralizes HBase configuration imports, and a DedupCache mechanism prevents duplicate host application map entries within the same time slot.

pinpoint-collector · high confidence

The Pinpoint banner display logic has been refactored into a new \PinpointBanner\ class that uses a builder pattern for configuration. Users can now control how the banner is printed by setting a \BannerMode\ (OFF, LOG, or CONSOLE) and providing custom suppliers for the banner text, property keys, and output destinations. This allows for more flexible integration of the startup banner into different logging or console environments.

pinpoint-banner · high confidence

Bootstrap module restructured with new agent initialization classes

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

Collector starter now supports modular startup via command-line collector types

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

Enhanced async tracing and error handling in the HTTPClient5 plugin

The HTTPClient5 plugin now provides more detailed tracing for asynchronous HTTP operations. It introduces new interceptors for connection management and future lifecycle events (cancel, complete, fail) to better capture the state of async requests. Additionally, the plugin now supports recording HTTP status codes and internal host details when enabled, and offers a configurable option to mark errors on failed futures, improving visibility into async request outcomes.

pinpoint-httpclient5-plugin · high confidence

HBase integration overhaul: async writes, namespace support, and concurrency controls

The HBase commons module has been significantly refactored to improve performance, stability, and configuration flexibility. Users can now leverage the new AsyncPollingPutWriter and HbaseAsyncTemplate for asynchronous data writes, which are protected by a Semaphore-based ConcurrencyLimiterHelper to prevent OutOfMemory errors during high-throughput operations. The module now supports explicit HBase namespaces via the HbaseTableNameProvider and validates them using HbaseNamespaceValidator. Additionally, a new HbaseVersionCheckBean ensures client-server compatibility at startup, while the updated RangeDoubleHash and ScanKey classes provide improved row-key distribution and type-safe scan boundaries.

pinpoint-commons-hbase · high confidence

HBase schema and Docker deployment updates

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

HTTP Client 4 plugin interceptors now respect markError configuration

The HTTP Client 4 plugin interceptors (BasicFutureFailedMethodInterceptor, HttpAsyncClientExecuteMethodInterceptor, and HttpClientConnectionManagerConnectMethodInterceptor) now read the markError configuration option to determine whether exceptions should be marked as errors in traces. This allows users to control error marking behavior for HTTP client operations via the profiler configuration.

pinpoint-httpclient4-plugin · high confidence

HttpClient 3 plugin adds error marking and internal connection details

The HttpClient 3 plugin interceptors now respect the 'mark.error' configuration option to conditionally record exceptions in traces. Additionally, the HttpConnectionOpenMethodInterceptor records the target host and port (including proxy details when applicable) as an internal display attribute, providing clearer visibility into the specific connection endpoint being established.

pinpoint-httpclient3-plugin · high confidence

Improved async context propagation and lifecycle correctness in Reactor plugin interceptors

The Pinpoint Reactor plugin now includes dedicated interceptors for delay, interval, publishOn, and subscribeOn operations that explicitly carry the AsyncContext to ensure asynchronous trace IDs are correctly linked. Additionally, the OnErrorSubscriberInterceptor and RetryWhenMainSubscriberInterceptor have been updated to carry the TraceBlock from before() to after(), preventing trace frame mismatches during error handling and retry resubscriptions. The RetrySubscriberResubscribeInterceptor also ensures that temporary async traces are properly closed and unbound during source resubscription, maintaining lifecycle correctness for periodic, retry, and seam subscribers.

pinpoint-reactor-plugin · high confidence

Improved async trace attribution for Reactor I/O seams

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

Improved error marking and async context handling in HTTP client plugins

The Google HTTP Client, JDK HTTP Client, and OkHttp plugins now respect the 'mark.error' configuration option to conditionally mark spans as errors based on exceptions. Additionally, the JDK and OkHttp plugins have been updated to properly carry AsyncContext across asynchronous invocations, ensuring that async traces are correctly linked and recorded.

pinpoint-google-httpclient-plugin, pinpoint-jdk-httpclient-plugin, pinpoint-okhttp-plugin · high confidence

Improved error tracking for AsyncHandler.onThrowable in AsyncHttpClient plugin

The AsyncHttpClient plugin now includes a dedicated interceptor for the AsyncHandler.onThrowable method, ensuring that exceptions thrown during asynchronous request handling are properly captured and recorded in traces. This change enhances observability by allowing users to see error details for async failures that were previously untracked, with the ability to mark these as errors based on the agent's profiler configuration.

pinpoint-ning-asynchttpclient-plugin · high confidence

Improved tracing for Redisson reactive commands in versions 3.17+

The Redisson plugin now correctly traces reactive commands for Redisson 3.17 and later. This is achieved by adding a new \ReactiveMethodInterceptor\ that handles async context propagation for reactive results and updates the method lookup logic to support Redisson 3.19+ proxy structures. Additionally, a \CommandAsyncServiceMethodInterceptor\ and \RedissonMethodNameFilters\ class were introduced to standardize argument validation, endpoint resolution, and method filtering for async commands.

pinpoint-redis-redisson-plugin · high confidence

Inspector collector now routes agent and application statistics to separate Kafka topics

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

Kafka plugin refactored for Kafka 3.x compatibility and Spring listener error handling

The Kafka plugin has been consolidated into a single module and updated to support Kafka 3.x versions, including new interceptors for \RecordCollector\ send methods introduced in Kafka 3.3.x. It now includes specific instrumentation for Spring Kafka's \KafkaMessageListenerContainer$ListenerConsumer\, featuring a new \ListenerConsumerInvokeErrorHandlerInterceptor\ that conditionally records exceptions based on the \kafkaMessageListenerContainerMarkError\ configuration setting.

pinpoint-kafka-plugin · high confidence

Kafka plugin restructured for Kafka 4.x compatibility and Spring Kafka support

The Kafka plugin has been reorganized into a single module with a new configuration model (KafkaConfig) and entry points to support Kafka client versions 0.11 through 3.x and prepare for 4.x. Users can now enable Spring Kafka consumer tracking via profiler.springkafka.consumer.enable and choose to use the KafkaMessageListenerContainer entry point with profiler.springkafka.container.enable. The plugin introduces a KafkaVersion utility to detect client versions and a KafkaClientUtils helper to safely handle record headers, ensuring compatibility with brokers that may not support them. Additionally, Kafka Streams tracing is now configurable via profiler.kafka-streams.enable and profiler.kafka-streams.trace.process, and the plugin registers new service types (KAFKA\_CLIENT, KAFKA\_STREAMS) and annotation keys for detailed trace data.

agent-module/plugins/kafka · high confidence

Lettuce plugin now supports PubSub listener tracing and refined method filtering

The Redis Lettuce plugin now includes tracing for PubSub listeners, controlled by the new configuration option tracePubSubListener, allowing users to monitor message listener activity in addition to standard commands. The plugin also introduces a dedicated method filter to exclude specific internal and object methods (such as clone, equals, and various connection setup methods) from instrumentation, reducing noise. Additionally, the plugin setup has been updated to integrate with Reactor's scheduler and publisher seams, ensuring accurate context propagation for reactive Redis operations.

pinpoint-redis-lettuce-plugin · high confidence

Logging implementation switches to PluginLogger interface

The profiler-logging module now uses the PluginLogger interface instead of the deprecated PLogger API. This change introduces a new Log4J2PluginLoggerAdapter and Log4j2Binder to handle logging, ensuring that the agent module integrates with the updated logging framework.

pinpoint-profiler-logging · high confidence

MariaDB JDBC plugin updated to support MariaDB Java Client 3.x

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

MongoDB Java Driver plugin supports versions up to 5.6.x

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

MySQL JDBC plugin refactored for MySQL Connector/J 9.x support

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

New agent configuration profiles for local and release environments

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

New modularized datasource configuration with HikariCP defaults

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

OTLP trace collector adds GenAI, gRPC/HTTP status, and agent identity mapping

The OTLP trace collector now maps OpenTelemetry semantic conventions to Pinpoint annotations and service types. GenAI attributes (model, token usage, time-to-first-token) are promoted to first-class call-tree annotations. HTTP and gRPC status codes are resolved and recorded as annotations. Client and server service types are derived from the rpc.system attribute (e.g., gRPC, Apache Dubbo), with HTTP clients falling back to a generic HTTP client type when rpc.system is absent. Agent identity is resolved from pinpoint.agentId, service.instance.id, k8s.pod.uid, container.id, or host.name, with an optional applicationName fallback. The agent start time is resolved from process.creation.time, and Pinpoint tracestate entries are parsed from the W3C tracestate header for upstream context propagation.

pinpoint-otlptrace-collector · high confidence

OkHttp plugin refactored to support version 2.x with improved async tracing and configuration

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

Plugins migrate to new PluginLogger API

The RxJava, Thrift, and User agent plugins have been updated to use the new PluginLogger API (replacing the deprecated PLogger). This change ensures consistent logging behavior across these plugins and removes reliance on deprecated internal APIs, preventing potential runtime issues in future agent versions.

pinpoint-rxjava-plugin, pinpoint-thrift-plugin, pinpoint-user-plugin · high confidence

Realtime collector module is disabled by default

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

Realtime collector switches from Thrift to gRPC for agent command connections

The realtime collector now uses gRPC instead of Thrift to handle incoming command connections from agents. This change introduces new gRPC-based service classes (GrpcCommandService, GrpcAgentConnection) to manage agent sessions, command routing, and lifecycle events (connect, cancel, close), replacing the previous Thrift-based implementation. Users will see the collector operating on the new gRPC transport layer for real-time agent commands.

pinpoint-realtime-collector · high confidence

Realtime web features now use Redis-backed channel communication

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

Refactor logging infrastructure to support Log4j2 YAML configuration and Java 8 date types

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

Refactored alarm sender to use Java configuration and updated webhook payloads

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

Refactored bootstrap initialization and logging infrastructure

The Pinpoint agent bootstrap module has been restructured to improve initialization reliability and logging clarity. A new BootLogger class provides structured, configurable logging for the agent startup process, replacing ad-hoc output with formatted trace, debug, info, warn, and error messages. Agent configuration is now managed via a new DefaultAgentOption class that explicitly handles paths using Java NIO Path objects for plugins, bootstrap JARs, and the agent directory, replacing previous string-based or less structured approaches. Additionally, the AgentDirBaseClassPathResolver has been updated to use Path-based resolution for locating the agent directory, boot libraries, and plugins, ensuring more robust path handling and clearer error reporting during agent startup.

pinpoint-bootstrap · high confidence

Refactored profiler context initialization and caching infrastructure

The pinpoint-profiler module introduces a new AgentOption configuration class to centralize agent startup parameters (such as agent path, plugin JARs, and bootstrap JARs) and replaces several internal components with more robust implementations. This includes a new SimpleCache backed by Caffeine for efficient ID generation, a DefaultAsyncTraceContext that uses a memoized supplier to resolve circular dependency cycles during initialization, and a DefaultActiveTraceRepository that accepts an externally provided bounded map to prevent memory leaks. Additionally, the profiler now supports configurable error filtering via ClassNameThrowableMatcher and ContainsMessageMatcher, and allows dynamic selection of the GuardedInterceptorFactory (codegen vs. disabled) based on the profiler.interceptor.exception.guard.codegen configuration flag.

pinpoint-profiler · high confidence

RestTemplate plugin refactored for Spring Framework 7 compatibility

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

Rich Datetime Picker component re-implementation in React

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

Scatter chart package restructured with Storybook, linting, and default options

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

Server Map component migrated to React with Storybook and Apdex visualization

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

Servlet plugin adds Jakarta EE 9+ support and configurable real-IP resolution

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

Spring WebFlux plugin now supports Spring Framework 7.0 and Spring Boot 4.1

The Spring WebFlux tracing plugin has been updated to support Spring Framework 7.0 and Spring Boot 4.1. To ensure compatibility, the plugin now detects the Spring version at runtime and uses version-specific providers for HTTP status codes and HTTP methods. Additionally, header access logic has been refactored to use methods compatible with Spring 5, 6, and 7, preventing runtime errors caused by API changes in Spring 7.0.

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

Spring WebFlux plugin refactored for Spring Framework 7.0 and Spring Boot 4.1 compatibility

The Spring WebFlux plugin has been updated to support Spring Framework 7.0 and Spring Boot 4.1. This includes adapting the DispatcherHandler instrumentation to handle new method signatures (such as handleResult with an additional String parameter) and integrating Reactor publisher seams and scheduler task carriers behind configuration gates. The plugin also unifies the reactor AsyncContext carrier into a single injected field and replaces deprecated APIs to ensure compatibility with the latest framework versions.

pinpoint-spring-webflux-plugin · high confidence

Spring plugin refactored to support Spring Framework 5.0–7.0 and Spring Boot 4.1

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

Test case module relocated to agent-module

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

Trace metadata YAML parsing switched to Jackson

The plugins-loader module now uses Jackson (via YAMLFactory) instead of SnakeYAML to parse trace metadata YAML files. This change replaces the underlying serialization library for loading trace provider definitions, which may affect parsing behavior and performance for users relying on these metadata files.

pinpoint-plugins-loader · high confidence

Trace metadata provider loader deduplicates identical definitions

The TraceMetadataProviderLoader now prevents duplicate trace metadata providers from being loaded when the same definition appears multiple times on the classpath (e.g., via both IDE class directories and packaged JARs). It deduplicates providers by comparing SHA-256 content digests in addition to checking for duplicate provider IDs, ensuring that identical YAML definitions are only processed once.

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

UriStat collector now uses profile-based Kafka configuration and property-driven activation

The URI stat collector in the collector module has been refactored to load Kafka topic configuration from profile-specific property files (e.g., \profiles/local/kafka-topic.properties\) rather than a static path, and its activation is now controlled by the \pinpoint.modules.collector.uristat.enabled\ property instead of the \uri\ profile. This change introduces a new \UriStatCollectorConfig\ that conditionally imports Kafka and Pinot configurations based on the property, ensuring the collector only initializes when explicitly enabled via configuration.

uristat/uristat-collector · high confidence

User module refactored to support Jakarta EE and post-commit group deletion listeners

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

Fixes

Fix MongoDB reactive streams driver interception and startup errors

The MongoDB agent plugin now correctly intercepts read and write operations for the reactive streams driver, ensuring that asynchronous calls are properly traced via AsyncContext. Additionally, the interceptor classes have been relocated to prevent NoClassDefFoundError issues during web application startup, improving stability for users running the agent in web environments.

pinpoint-mongodb-driver-plugin · high confidence

Test coverage

4 commits adding/updating tests in agent-module/plugins/kotlin-coroutines/src/test; 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 4.x consumer test harness; Added Kafka plugin test web applications; Added Maru test helper class for Spring 5 integration tests; 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 Thrift echo test client and server implementations; Added agent-proxy-plugin-testweb test harness; Added gRPC streaming test client for plugin testing; Added integration test for Fastjson plugin; Added integration test for Ning AsyncHttpClient plugin; Added integration test infrastructure for Kafka 3 consumer tracing; Added integration test support for Kafka 2 consumer tracing; 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 high-level client plugins; Added integration tests for Elasticsearch 7.16.x plugin; Added integration tests for Google HTTP Client, iBatis, and RabbitMQ plugins; Added integration tests for HBase client operations; Added integration tests for HikariCP, Hystrix, and JSON-Lib plugins; Added integration tests for JDK HttpURLConnection plugin; Added integration tests for Jackson plugin; Added integration tests for Kafka client plugin across multiple versions; Added integration tests for Kotlin coroutines plugin; 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 Oracle JDBC drivers (ojdbc8 and ojdbc10); Added integration tests for PostgreSQL JDBC driver versions; 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 command tracing; Added integration tests for Spring Bean tracing with Lambda expressions; Added integration tests for Thrift 0.10 and 0.14 plugins; Added integration tests for Thrift 0.14.x async and sync server variants; Added integration tests for the Apache HttpClient 3 plugin; Added integration tests for the Commons DBCP plugin; Added integration tests for the Druid JDBC plugin; Added integration tests for the HTTP Client 5 plugin; Added reactor-plugin-testweb test application; Added test configuration files for agent integration tests; Added test controller for Ning AsyncHttpClient plugin; Added test helper for thread integration tests; Added test infrastructure for agent profiler validation; Added test resource configurations for logging; Added test resources for ClickHouse, Informix, MSSQL, and Spring Data R2DBC integration tests; Added test resources for bootstrap configuration and MariaDB integration tests; Added test utilities for profiler integration testing; 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 WebServer utility; Added tests for async interceptor trace context handling and span lifecycle; Added tests for shared plugin test infrastructure components; Added tests for the maven-resolver plugin distribution and class-loading behavior; Added tests for trace metadata provider loading and YAML parsing; Added testweb for AWS SDK S3 plugin verification; 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 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; New internal test-support classes for plugin testing; New plugin test API annotations and contracts; Spring 5 integration tests migrated to new test API and version-specific modules.

Dependencies

Dependency updates and cleanup across 357 manifests

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

Updated Maven Wrapper to version 3.9.16

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

How this codebase got here

Score

  • CAI 47 → 47 (-0.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 64 → 63 (-0.3)
  • Architecture 61 → 54 (-6.4)
  • Maturity 66 → 44 (-22.3)
  • Readiness 43 → 47 (+4.2)
  • Security 62 → 61 (-0.2)
  • Domain Modelling 100 → 100 (+0.0)
  • Accessibility 40 → 42 (+2.7)
  • Performance 78 → 100 (+21.7)

Resolved (185)

  • Change coupling clique: HbaseAgentEventDao.java, HbaseAgentInfoDao.java, HbaseAgentLifeCycleDao.java (commons-server/src/main/java/com/navercorp/pinpoint/common/server/dao/hbase/HbaseAgentEventDao.java)
  • Change coupling clique: HbaseMapAgentResponseTimeDao.java, HbaseMapInLinkDao.java, HbaseMapOutLinkDao.java (applicationmap/src/main/java/com/navercorp/pinpoint/applicationmap/dao/hbase/HbaseMapAgentResponseTimeDao.java)
  • Change coupling: PingStreamContext.java ↔ ResponseStreamObserver.java (agent-module/profiler/src/main/java/com/navercorp/pinpoint/profiler/sender/grpc/PingStreamContext.java)
  • Critical CVE: [GHSA redacted] (agent-module/plugins/resttemplate/pom.xml)
  • Critical CVE: [GHSA redacted] (quickstart/testapp/pom.xml)
  • Critical CVE: [GHSA redacted] (web-frontend/src/main/v3/yarn.lock)
  • Critical CVE: [GHSA redacted] (agent-module/plugins/spring-stub/pom.xml)
  • Critical CVE: [GHSA redacted] (web-frontend/src/main/v3/yarn.lock)
  • Critical CVE: [GHSA redacted] (agent-module/plugins-it/spring-it/spring-5-it/pom.xml)
  • Critical CVE: [GHSA redacted] (web-frontend/src/main/v3/yarn.lock)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Documentation: no project overview (agent-module/plugins-it/README.md)
  • Duplicated block (10 lines × 2) (hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/task/InitTask.java)
  • Duplicated block (11 lines × 2) (batch/src/main/java/com/navercorp/pinpoint/batch/config/AgentCountJobConfig.java)
  • Duplicated block (11–12 lines × 2) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/JettyConfiguration.java)
  • Duplicated block (11–13 lines × 2) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/JettyPlugin.java)
  • Duplicated block (11–17 lines × 3) (agent-module/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHousePlugin.java)
  • Duplicated block (12 lines × 2) (agent-module/plugins/akka-http/src/main/java/com/navercorp/pinpoint/plugin/akka/http/AkkaHttpPlugin.java)
  • Duplicated block (12 lines × 3) (agent-module/plugins/gson/src/main/java/com/navercorp/pinpoint/plugin/gson/GsonConfig.java)
  • Duplicated block (12–13 lines × 2) (agent-module/plugins/hikaricp/src/main/java/com/navercorp/pinpoint/plugin/hikaricp/HikariCpDataSourceMonitor.java)
  • …and 165 more

New (879)

  • Banned license: com.mysql:mysql-connector-j
  • Change coupling: HbaseAgentEventDao.java ↔ HbaseAgentInfoDao.java (commons-server/src/main/java/com/navercorp/pinpoint/common/server/dao/hbase/HbaseAgentEventDao.java)
  • Change coupling: HbaseAgentInfoDao.java ↔ HbaseAgentLifeCycleDao.java (web/src/main/java/com/navercorp/pinpoint/web/dao/hbase/HbaseAgentInfoDao.java)
  • Change coupling: HbaseMapInLinkDao.java ↔ HbaseMapOutLinkDao.java (applicationmap/src/main/java/com/navercorp/pinpoint/applicationmap/dao/hbase/HbaseMapInLinkDao.java)
  • ClassTooLong: OtlpMetricInspectorMapper (otlptrace/otlptrace-inspector/src/main/java/com/navercorp/pinpoint/otlp/trace/inspector/OtlpMetricInspectorMapper.java)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/cassandra3-plugin-testweb/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/pulsar-plugin-testweb/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/dubbo-plugin-testweb/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/rocketmq-plugin-testweb/rocketmq-springcloud-stream/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/dubbo-plugin-testweb/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/cassandra3-plugin-testweb/pom.xml)
  • Critical CVE: [GHSA redacted] (agent-module/agent-testweb/dubbo-plugin-testweb/pom.xml)
  • Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
  • Duplicated block (10 lines × 2) (collector/src/main/java/com/navercorp/pinpoint/collector/scheduler/AvgMaxLinkScheduler.java)
  • Duplicated block (11 lines × 2) (collector/src/main/java/com/navercorp/pinpoint/collector/scheduler/AvgMaxLinkScheduler.java)
  • Duplicated block (12 lines × 2) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/jakarta/interceptor/AbstractServerHandleInterceptor.java)
  • Duplicated block (14 lines × 2) (alarm/alarm-web/src/main/java/com/navercorp/pinpoint/alarm/web/service/AlarmConfigValidator.java)
  • Duplicated block (14–15 lines × 2) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/JettyConfiguration.java)
  • Duplicated block (16 lines × 2) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/JettyConfiguration.java)
  • Duplicated block (17 lines × 3) (agent-module/plugins/jetty/src/main/java/com/navercorp/pinpoint/plugin/jetty/jakarta/interceptor/AbstractServerHandleInterceptor.java)
  • …and 859 more

Changes since last survey

  • 145 commits — 139 feature/other, 6 fixes

By area

  • (root) — 44 commits
  • web-frontend/src — 20 commits
  • agent-module/plugins — 17 commits
  • web/src — 10 commits
  • otlptrace/otlptrace-linkindex — 9 commits
  • alarm/alarm-common — 6 commits
  • agent-module/agent-testweb — 4 commits
  • batch/src — 4 commits
  • collector/src — 4 commits
  • agent-module/plugins-test-module — 3 commits
  • agent-module/profiler — 3 commits
  • .github/workflows — 2 commits
  • alarm/alarm-batch — 2 commits
  • alarm/alarm-web — 2 commits
  • commons-server/src — 2 commits
  • agent-module/agent — 1 commit
  • agent-module/plugins-it — 1 commit
  • agent-module/pom.xml — 1 commit
  • alarm/alarm-core — 1 commit
  • basic-login/README.md — 1 commit

Notable commits

  • fix: [#noissue] Bump handlebars, storybook and shell-quote to fix critical vulnerabilities
  • fix: [#noissue] Bump postcss-selector-parser to 7.1.7 to fix a moderate vulnerability
  • fix: [#noissue] Bump vite, zod and transitive deps to fix high vulnerabilities
  • fix: [#noissue] Fix Maven Central deploy workflow
  • fix: [#noissue] Fix the agent path and the agent JVM arguments of the agent-testweb sample apps
  • fix: [#noissue] Fix the order-dependent failure of the reactor plugin tests
  • change: [#14474] Add Envoy service type and annotation keys to display Envoy trace data
  • change: [#14486] Bump undertow to 2.2.41.Final and fastjson to 1.2.84 in the agent-module plugin properties
  • change: [#14486] Import junit-bom ahead of spring-boot-dependencies in the Boot 2/3 testwebs
  • change: [#14494] Pin brotli4j to 1.24.0 through brotli4j-bom and import it ahead of quarkus-bom in the quarkus testweb
  • change: [#14502] 4.0.0 release
  • change: [#14502] Prepare 4.0.1-SNAPSHOT
  • change: [#14502] Update README.md
  • change: [#14510] Bump spring framework from 6.2.18 to 6.2.19
  • change: [#14511] Bump spring boot from 3.5.14 to 3.5.16
  • change: [#14512] Bump jackson from 2.21.4 to 2.21.8
  • change: [#14513] Bump log4j2 from 2.25.4 to 2.25.5
  • change: [#14514] Bump spring batch from 5.2.5 to 5.2.6
  • change: [#14515] Bump spring security from 6.5.10 to 6.5.11
  • change: [#14516] Bump spring retry from 2.0.12 to 2.0.13
  • …and 125 more

Architecture

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

Added bounded contexts (1)

  • pinpoint-otlptrace-inspector

Added dependency edges (2)

  • pinpoint-otlptrace-collector → pinpoint-otlptrace-inspector
  • pinpoint-otlptrace-inspector → pinpoint-commons-server

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

Survey your own repository

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.

About this page

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