pinpoint-apm/pinpoint
Pinpoint
Pinpoint is a distributed application performance management tool designed to trace requests and monitor metrics across large-scale distributed architectures. It functions as a request tracer, topology mapper, and JVM application monitor, providing a backend capable of collecting and visualizing trace data from OpenTelemetry compatible sources.
The system distinguishes itself through a combination of bytecode-based instrumentation via a Java agent and topology-based visualization that renders live maps of service interconnections. It captures execution flow across asynchronous boundaries, such as reactive streams and coroutines, and utilizes a gRPC-based ingestion framework to transmit spans and metrics from agents to the collector.
The project covers a broad range of observability capabilities, including deep call stack and request pattern analysis for root cause diagnostics. It provides extensive integration monitoring for various web servers, database drivers, messaging brokers, and serialization libraries, while simultaneously tracking JVM resource health such as CPU usage, memory consumption, and garbage collection patterns.
Features
- Application Performance Monitoring - Analyzes call stacks and transaction response times to pinpoint the exact line of code causing performance degradation.
- Database Performance Monitoring - Monitors query execution times and connection pool utilization across various JDBC drivers to resolve data access bottlenecks.
- Distributed Tracing Backends - Provides a backend for storing and analyzing distributed trace data from compatible sources.
- Topology Visualizers - Aggregates trace dependencies to render a live map of service interconnections and system health statuses.
- Distributed Trace Propagation - Maintains trace context across service boundaries using headers to map upstream callers.
- Trace Data Ingestion - Implements endpoints for receiving distributed trace spans via gRPC or HTTP protocols.
- Tracing Context Propagation - Injects unique identifiers into request headers to link spans across multiple microservices and reconstruct call chains.
- Runtime Bytecode Instrumentation - Injects monitoring logic into application binaries at runtime via a Java agent to capture execution metrics.
- Asynchronous Tracing - Captures execution flow across reactive streams and coroutines to maintain trace continuity in non-blocking applications.
- Coroutine State Inspection - Analyzes the execution state and stack traces of active Kotlin coroutines to maintain trace continuity.
- Distributed APM Tools - Provides a performance management system that traces requests and monitors metrics across large-scale distributed architectures.
- JVM Application Monitoring - Tracks thread activity, garbage collection, and resource utilization specifically for Java applications.
- Metric Data Ingestion - Collects and imports large volumes of performance metrics and agent data into a centralized store.
- Distributed Tracing - Tracks requests across distributed systems using unique identifiers to analyze execution flow and bottlenecks.
- Distributed Request Tracers - Tracks request flows and visualizes dependencies across multiple interconnected services to identify bottlenecks.
- JVM Resource Monitoring - Tracks real-time CPU usage, memory consumption, and garbage collection patterns to optimize Java application health.
- System Health Monitors - Tracks real-time system metrics including CPU usage, memory, and transaction throughput to assess overall health.
- Connection Pool Observability - Tracks the performance and usage of database connection pools to identify data access bottlenecks.
- MongoDB Driver Monitoring - Tracks the execution of database operations performed via the MongoDB Java driver.
- Instrumentation Filters - Applies include and exclude rules to determine which specific packages or classes should be instrumented.
- Response Time Trend Analysis - Analyzes request counts and response time distributions over time to detect performance anomalies.
- MySQL Driver Monitoring - Tracks the execution of database queries via the MySQL JDBC driver to analyze latency.
- Query Performance Monitors - Analyzes MyBatis database logs and execution statistics to identify query bottlenecks.
- Asynchronous Request Tracing - Tracks execution and latency of asynchronous HTTP client requests to visualize network call patterns.
- Distributed Tracing - Collects and visualizes trace data from OpenTelemetry compatible sources via gRPC or HTTP.
- Performance Monitoring - Tracks performance and traces requests flowing through gRPC services to identify bottlenecks.
- RPC Execution Tracing - Provides tracing and monitoring of the active lifecycle of remote procedure calls implemented using the Apache Thrift framework.
- Database Performance Monitors - Tracks real-time metrics and execution times for database queries made via the JTDS driver.
- End-to-End Message Tracing - Tracks the full lifecycle of MQTT publications and subscriptions to identify performance bottlenecks.
- Function Monitoring - Aggregates metrics, logs, and traces from serverless functions running within OpenWhisk.
- Trace-to-Log Mappers - Maps Log4j2 logging events to trace span attributes to correlate logs with transaction data.
- Messaging Performance Diagnostics - Analyzes the performance and latency of message producers and consumers across Kafka, RabbitMQ, and RocketMQ.
- HTTP Client Monitoring - Monitors and records the execution time and details of HTTP requests made via the OkHttp client.
- Database Monitoring - Provides performance tracking and metric collection specifically for IBM DB2 database systems.
- Thread Activity Monitors - Provides real-time tracking of active threads to identify concurrency issues and application hangs.
- Server Status Monitors - Tracks request and response metrics for the Jetty web server to identify performance bottlenecks.
- Observability Tracing - Captures and records logging activity from the Log4j framework to provide observability traces.
- Instrumentation Path Filtering - Defines include and exclude patterns to control which specific packages or classes are tracked.
- Query Performance Monitoring - Tracks and visualizes the performance of data processing queries sent via the Informix JDBC driver.
- Reactive Stream Monitoring - Tracks the execution flow and performance of asynchronous data streams.
- Root Cause Analysis - Diagnoses the source of application errors and performance degradation by linking them to specific traces.
- Reactive Web Server Monitoring - Monitors the performance and flow of asynchronous requests across Netty, Tomcat, Undertow, and Jetty.
- Web Server Performance Monitoring - Tracks the execution and performance of requests processed by the Apache Tomcat web server.
- Spring Framework Monitoring - The product tracks execution and performance metrics for Spring-based applications.
- Code-Level Transaction Analysis - Provides detailed inspection of transactions at the method and line level to pinpoint performance bottlenecks.
- HTTP Client Monitoring - Tracks and analyzes the performance of requests made via the JDK HttpClient.
- Distributed Tracing - Performance management for large-scale distributed architectures.
