Open-Source Observability · pinpoint-apm

pinpoint

Pinpoint is an open-source Application Performance Management (APM) tool designed for monitoring and tracing transactions across large-scale distributed systems. It provides real-time visibility into application topology, code-level transaction details, and performance metrics with minimal overhead (~3% resource usage).

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/pinpoint-apm/pinpoint

13.8k

GitHub stars

3.8k

Forks

Java

Primary language

Apache-2.0

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	pinpoint-apm/pinpoint
Owner	pinpoint-apm
Primary language	Java
License	Apache-2.0 — OSI-approved
Stars	13.8k
Forks	3.8k
Open issues	531
Latest release	v3.1.0 (2026-05-20)
Last updated	2026-07-08
Source	https://github.com/pinpoint-apm/pinpoint

What pinpoint is

Pinpoint is a Java-based APM platform inspired by Google Dapper that uses bytecode instrumentation to trace transactions across distributed systems without code changes. It supports JDK 8+, a wide range of frameworks (Spring, Tomcat, Jetty, etc.), RPC protocols (Thrift, gRPC, Dubbo), messaging systems (Kafka, RabbitMQ, ActiveMQ), and databases (MySQL, PostgreSQL, Oracle, etc.), with additional C-based agents for PHP and Python.

Quickstart

Get the pinpoint source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/pinpoint-apm/pinpoint.git2cd pinpoint3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Large-scale microservices topology mapping

Automatically visualize service dependency graphs and interdependencies without manual configuration, enabling quick identification of architectural bottlenecks and communication patterns across dozens or hundreds of services.

Real-time transaction tracing and debugging

Gain end-to-end visibility into individual request flows across multiple services with call stack inspection, enabling rapid diagnosis of latency issues and failure points at the code level without modifying application code.

Performance baseline monitoring for Java/Spring applications

Monitor active threads, GC behavior, JVM metrics, and URI-level performance statistics in real-time to detect anomalies, resource exhaustion, and performance regressions as they occur.

Implementation considerations

Agent deployment requires JVM parameter injection (no code changes required); verify compatibility with application startup scripts and container orchestration before production rollout.
Backend storage uses HBase; plan for cluster setup, data retention policies, and backup strategy. Kubernetes deployment reference available at pinpoint-kubernetes repository.
Wide plugin support, but verify your exact framework versions and custom libraries have instrumentation; check plugin repository for coverage gaps.
Sampling and filtering configuration critical at scale to manage storage and query performance; start conservative and tune based on baseline metrics.
Transaction ID correlation across services relies on header propagation; ensure your HTTP/RPC frameworks and custom code preserve trace context.

When to avoid it — and what to weigh

Serverless or event-driven architectures — Pinpoint's agent-based instrumentation model is designed for long-running processes. Deployment on AWS Lambda, Azure Functions, or similar short-lived compute may not fit the monitoring lifecycle or add significant cold-start overhead.
Non-Java backend stack as primary focus — While Pinpoint supports PHP and Python via a separate C agent, primary development and plugin ecosystem target Java. Mixed-stack environments where Java is not the dominant runtime may face incomplete instrumentation and plugin gaps.
Highly constrained resource environments — Although overhead is claimed at ~3%, agent-based instrumentation in memory-constrained containers or edge deployments may be problematic. Evaluate actual footprint for embedded or IoT scenarios.
Requirement for SaaS-managed solution — Pinpoint is self-hosted only. Organizations without infrastructure for backend deployment, HBase storage, and collector/UI maintenance should consider SaaS alternatives (Datadog, New Relic, etc.).

License & commercial use

Licensed under Apache License 2.0 (Apache-2.0), a permissive OSI-approved license permitting commercial use, modification, and distribution with minimal restrictions (requires license and copyright notice).

Apache-2.0 clearly permits commercial deployment and use. No proprietary restrictions or commercial licensing fees imposed by the project. Organizations must respect the license terms (include license notice, document changes) but face no usage-based fees or restrictions on internal or customer-facing use.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Moderate
DEV.co fit	Good
Assessment confidence	High

Security considerations

Project does not publish security advisories or policies in provided data. Agent-based instrumentation runs with application JVM privileges; verify bytecode injection risk in your threat model. Network communication between agents and collector should use TLS in production; verify configuration options. No security audit or certification claims stated. Conduct security review of plugin implementations for your critical frameworks before production.

Alternatives to consider

Jaeger (open-source distributed tracing)

Cloud-native, Kubernetes-friendly, supports OpenTelemetry standard. Better for polyglot architectures but requires explicit instrumentation code; lower overhead in serverless.

Datadog APM

SaaS-managed, broader platform (logs, metrics, traces), lower operational overhead. Higher cost, vendor lock-in; no self-hosted option.

New Relic One APM

SaaS offering with auto-instrumentation agents for Java. Simpler ops, broader feature set (infrastructure monitoring, NRQL), but requires cloud account and subscription fees.

Software development agency

Build on pinpoint with DEV.co software developers

Pinpoint offers powerful, self-hosted distributed tracing with minimal instrumentation effort. Evaluate deployment requirements, HBase infrastructure planning, and plugin compatibility for your stack. Contact our DevOps team for proof-of-concept guidance.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

traceway pmm javamelody

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability DevOps & Monitoring API Development Cloud Deployment Talk to DEV.co

pinpoint FAQ

Does Pinpoint require code changes to existing applications?

No. Pinpoint uses bytecode instrumentation via JVM agent parameter. Deploy the agent JAR and pass a single JVM flag (-javaagent); existing application code remains unchanged. Agent auto-discovers supported frameworks and libraries.

What is the storage backend and scaling model?

Pinpoint uses HBase for time-series data storage. You provision and manage the HBase cluster. Scaling requires HBase cluster expansion. For managed alternatives, consider Kubernetes-based Pinpoint deployment or SaaS competitors.

Can I monitor non-Java applications with Pinpoint?

Pinpoint provides C-based agents for PHP and Python (pinpoint-c-agent repository), but the core ecosystem, plugins, and maintenance focus Java. Mixed-stack environments may have incomplete instrumentation; evaluate plugin coverage for your stack.

What is the performance overhead?

Documentation claims approximately 3% increase in resource usage. Actual overhead depends on transaction volume, sampling configuration, and instrumentation depth. Conduct load testing with your production workload profile before deploying.

Custom software development services

DEV.co helps companies turn open-source tools like pinpoint into production software. Our software development services cover the full lifecycle — architecture, web development, integration, and maintenance — delivered by software developers and web developers who ship. Engage our software development agency to implement or customize it for your open-source observability stack.

Ready to deploy APM for your Java microservices?

Talk to DEV.co Schedule a Consultation