pinpoint-apm/pinpoint
46.7
Weak · 13 November 2026
442.8k
lines of production code
Java
with TypeScript
7
measurements over time
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
Introduce standalone Basic Login module with secure JWT cookie defaults
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
Banner functionality extracted into a standalone module
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
Banner output is now configurable via a builder pattern
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.