Open Source and Free APM Tools

This content was last reviewed on
September 11, 2022

Because of the complexity and variety of data sources we see in modern microservices-based architectures, it is becoming more difficult to understand the underlying cause of problems. Application Performance Monitoring or Application Performance Management (APM) helps organizations collect, process, and visualize the telemetry data from different systems to troubleshoot issues faster.

There are many open-source and vendor-provided APM tools. Below we cover some of the open-source APM tools worth looking at.

Get a report on the best APM and Observability provider. Tailored to your exact use case.
Get My Free APM Evaluation
It takes 5 minutes

Prometheus

GitHub: https://github.com/prometheus

Prometheus was originally built at SoundCloud in 2012 before being released as an open-source project. It joined the Cloud Native Computing Foundation (CNCF) as the second hosted project after Kubernetes. 

Prometheus has multiple components:

  • Prometheus server: Scrapes and stores time-series data .
  • Client libraries: These are used to instrument application code.
  • Pushgateway: Supports short-lived jobs.
  • Special Purpose exporters: For services such as HAProxy, StatsD, Graphite, etc.
  • Alertmanager: To handle alerts.

Key features of Prometheus:

  • Implements a highly dimensional data model.
  • Powerful queries with custom query language PromQL allow slicing and dicing the collected time-series data to generate visualizations and alerts.
  • Visualizations with a built-in browser, Grafana integration, and a console template language.
  • Efficient storage.
  • Independent server nodes for reliability, relying on local storage.
  • Alerts through the Alertmanager.
  • Client libraries that allow easy instrumentation of services.
  • Supports many integrations.
Source: Prometheus

Pinpoint

GitHub: https://github.com/pinpoint-apm/pinpoint

Pinpoint is an APM tool for large-scale distributed systems written in Java/PHP/Python, inspired by Google's Dapper. It traces transactions across distributed applications and analyzes the overall structure of the systems and the interconnections of components within them. 

Pinpoint has multiple components:

  • ServerMap: To visualize how components are interconnected 
  • Realtime Active Thread Chart: To monitor active threads inside applications
  • Request/Response Scatter Chart: To visualize request count and response patterns over time to identify potential problems.
  • CallStack: To identify bottlenecks and points of failure by gaining code-level visibility
  • Inspector: To view additional details such as CPU Usage, Memory/Garbage Collection, TPS, and JVM arguments.

Key features of Pinpoint:

  • Application topology at a glance.
  • Real-time monitoring of applications.
  • Code-level visibility to every traction.
  • Installation of APM agents without code changes.
  • Minimal impact on the performance of applications.
Source: Pinpoint

Stagemonitor

GitHub: https://github.com/stagemonitor/stagemonitor

Stagemonitor is an open-source APM tool designed for Java server applications. It can be deployed in a data center, and private mode can be turned on for added security. It integrates with tools such as Graphite, InfluxDB, and Elasticsearch for graphed metrics analysis and integrates with Kibana for analyzing requests and call stacks. It has pre-configured Grafana and Kibana dashboards and is very customizable.

Stagemonitor has multiple components:

  • In-Browser Widget: Does not require any backend and is easy to set up.
  • Metrics tab: Real-time metrics collected in tables and graphs are displayed in this tab.
  • Call Tree View: The method call tree of the current request, including SQL statements to identify the bottlenecks of a request, is displayed here.
  • Request trace: Displays detail-level information about a request.
  • Configuration tab: Displays the available Stagemonitor configurations that can be dynamically updated.

Key features of Stagemonitor:

  • Correlates requests in a distributed system by using OpenTracing API. 
  • Can be used in different environments such as development, QA, and production.
  • Alerts can be sent when there are changes in the defined thresholds of metrics.
  • It is very reliable and extendable and supports standard plugins or third-party plugins.
Source: Stagemonitor

Scouter

GitHub: https://github.com/scouter-project/scouter

Scouter is an open-source APM tool written in Java, Javascript, and Scala. It captures active and recent users, active service, Transactions Per Second (TPS), Response time, Application profiles, CPU, Memory, Network and Heap usage, connection pools, etc. 

Scouter has multiple components:

  • Java Agent or JVM Agent: Gathers profiles and performance metrics of JVM and web applications and sends them to the server.
  • Host or OS agent: Gathers metrics of OS such as Linux, Windows, etc., and sends them to the server.
  • Server (Collector): Collects the performance metrics from scouter agents and sends the data to the Scouter client.
  • Client (Viewer): A client program based on RCP.
  • Web API: These get counters, XLogs, profiles, and additional performance metrics via HTTP protocol.
  • Weaver: Provides the ability to directly control Scouter XLog and profiles at the code level of Java applications.
Source: Scouter

App Metrics

GitHub: https://github.com/AppMetrics/AppMetrics

App Metrics is an open-source and cross-platform .NET library that is used to record application metrics. It can run on .NET Core or a full .NET framework supporting .NET 4.5.2. By sampling and aggregating in memory and providing extensibility points to flush metrics to a repository at a specified interval, it abstracts away the underlying metrics repository (e.g., InfluxDB, Prometheus, Graphite, Elasticsearch). It provides various metrics to measure the rate of requests, count of user logins over time, the execution time of database queries, free memory, etc.

Key features of AppMetrics:

  • Application metrics can be captured within any type of .NET application such as Windows Service, MVC Site, Web API, etc.
  • Measures the performance and error of each endpoint in an MVC or Web API project.
  • Measures client requests and error rates when securing API with OAuth2.
  • Supports Push and Pull based metrics collection, writing metrics to file, and pushing metrics to a custom HTTP endpoint.
Source: AppMetrics

Graphite

GitHub: https://github.com/graphite-project/graphite-web

Graphite is an open-source APM tool that does not collect data but stores numeric time-series data and renders graphs on demand. With little changes to the application code, data can be sent to Graphite. Sometimes, instead of changing application code, users can leverage tools such as collectd, Collectl, telegraf, Ganglia, etc. to send data to Graphite. Graphite has a web platform that offers a variety of output styles and formats such as raw images, CSV, XML, and JSON. With this feature, anyone can easily embed custom graphs in other web pages or dashboards.

Graphite consists of three software components:

  • Carbon: Listens for time-series data
  • Whisper: Simple database library for storing time-series data 
  • Graphite Web App: The user interface and API to render graphs on demand. 

Metrics are sent to the stack via the Carbon service, which then writes the data to Whisper for long-term storage. Users interact using the Graphite Web UI or API front end, which queries Carbon and Whisper to fetch the data and show it in graphs.

Source: Graphite

Glowroot

GitHub: https://github.com/glowroot/glowroot

Glowroot is an open-source APM tool to monitor Java-based applications that is very easy to use. Due to extensive micro-benching and tuning of Glowroot itself, it has very low overhead, generally in the low microseconds.

Glowroot can be implemented in two ways:

  • Embedded collector: Used to monitor stand-alone applications
  • Central collector: Used to monitor distributed systems 

Key features of Glowroot:

  • Trace capture for slow requests and errors.
  • Continuous profiling.
  • Response time breakdown and percentile charts.
  • Service call and SQL capture and aggregation.
  • Configurable alerting.
  • Historical roll-up of all data with configurable retention.
  • Responsive UI with mobile support.

Source: Glowroot

Javamelody

GitHub: https://github.com/javamelody/javamelody

JavaMelody is an open-source APM tool that monitors Java or Java EE applications. It does not simulate user requests but measures and calculates statistics of the application based on real usage. It provides different charts or visualizations that measure execution times, memory, CPU, number of user sessions, number of JDBC connections, percentage of errors of HTTP requests, SQL requests, JSF actions, etc.

Key features of Javamelody:

  • Optimize applications and resources and find root causes of slow response times.
  • Verify improvements after optimizations.
  • Provides Real User Monitoring (RUM) and Database monitoring.
  • Real-time notifications and alerts.
  • Seamless plugins and Integrations with third-party tools.
Source: Source: Javamelody
Get a report on the best APM and Observability provider. Tailored to your exact use case.
Get My Free APM Evaluation
It takes 5 minutes

Disclaimer: Taloflow does not guarantee the accuracy of any information on this page including (but not limited to) information about 3rd party software, product pricing, product features, product compliance standards, and product integrations. All product and company names and logos are trademarks™ or registered® trademarks of their respective holders. Use of them does not imply any affiliation or endorsement. Vendor views are not represented in any of our sites, content, research, questionnaires, or reports.