The OpenTelemetry integration in Applications Manager: Unified visibility for distributed applications

A user places an order, and a single request can set off a chain of events: One service processes the request, another handles the payment, a database stores the details, and additional services may handle notifications or other tasks. By the time the response reaches the user, the request may have passed through multiple services, databases, containers, and cloud environments.

When everything works as expected, this entire journey happens behind the scenes. Yet when the transaction slows down or fails, how do you know where the problem started? Was it a slow service, a database query, or a dependency further down the chain?

In distributed applications, being able to trace that journey from beginning to end is essential for understanding performance issues and finding their root cause. While modern architectures improve scalability and flexibility, they also tend to complicate performance monitoring and troubleshooting.

A single user transaction may traverse multiple services before reaching its destination, which makes it difficult to determine where delays or failures occur. To help teams gain better visibility into complex environments, Applications Manager now supports OpenTelemetry integration.

Understanding OpenTelemetry  

OpenTelemetry is an open-source observability framework that provides a standardized way to collect telemetry data from applications and infrastructure. It enables organizations to instrument applications using vendor-neutral APIs, SDKs, and protocols and export telemetry data to observability platforms for analysis.

As cloud-native and microservices-based architectures continue to evolve, applications are becoming increasingly distributed. A single transaction can span multiple services, technologies, and environments. OpenTelemetry helps capture that journey, providing the telemetry needed to understand what happens along the way.

Why organizations use OpenTelemetry  

Traditional monitoring approaches can leave teams with pieces of the puzzle spread across different tools. One tool may show application performance, another may reveal infrastructure metrics, while another provides application traces.

OpenTelemetry brings a standardized approach to telemetry collection, helping address some of the common challenges of monitoring distributed applications.

By standardizing telemetry collection, organizations can instrument applications consistently across different technologies and environments.

The OpenTelemetry integration in Applications Manager  

Applications Manager extends OpenTelemetry's telemetry collection by providing a platform for analyzing and visualizing distributed trace data. With this integration, teams can bring telemetry data into Applications Manager and explore application behavior through dashboards, transaction traces, dependency maps, and analytics views.

The key capabilities include:

• Distributed trace analysis: Track requests across services to understand the transaction flow and identify performance bottlenecks.

  

• Transaction-level visibility: Analyze response times, request paths, failures, and service interactions from end to end.

  

• Service dependency mapping: Visualize service relationships and understand application dependencies.

• Exception tracking: Monitor and correlate application errors within transaction traces.

• Database and SQL operation visibility: Review database calls, SQL execution details, and query performance.

• Threshold-based alerting: Configure alerts based on thresholds to stay informed about performance anomalies and application issues.

Instead of investigating each component in isolation, teams can use the trace as a starting point and work their way through the transaction to find where the problem begins.

Centralized visibility across distributed services  

A distributed application rarely keeps all its activity in one place. Services may run across different environments, communicate with one another, and depend on databases or other downstream components. This can make troubleshooting especially difficult when an issue in one service creates a ripple effect elsewhere.

Applications Manager brings OpenTelemetry telemetry into a centralized monitoring experience, helping teams see how application components interact and how an issue in one part of the environment can affect another.

Teams can:

• Follow service-to-service communication paths.

• Visualize dependencies between application components.

• Analyze interactions across distributed services.

• Investigate the impact of service failures on downstream components.

This consolidated view reduces the need to switch between multiple tools during an investigation. Instead, teams can follow the transaction, move through its dependencies, and pinpoint the source of the problem from a single monitoring experience.

Supported languages and technologies  

Distributed applications are rarely built using a single programming language. One service may run on Java, another may run on Python, and another may use .NET or Node.js. Applications Manager supports telemetry ingestion from OpenTelemetry-instrumented applications across major programming ecosystems, including the following:

• Java

• Node.js

• Python

• .NET

• Go

• Ruby

• PHP

• Rust

• Swift

• Elixir

• C++

• C#

This support helps organizations maintain observability across multi-language application environments without losing visibility as applications grow more complex.

Turn distributed traces into actionable visibility

OpenTelemetry provides the telemetry needed to follow a transaction across a distributed application. Applications Manager helps turn that trace data into a clearer view of application behavior, service dependencies, exceptions, and database operations. With OpenTelemetry support in Applications Manager, teams can analyze trace data across microservices, containers, and hybrid environments, helping them identify bottlenecks faster and reduce the time spent tracking down performance issues.

See how OpenTelemetry tracing can help you troubleshoot distributed applications faster. Try it in Applications Manager today.