Support Center Home


Distributed Tracing Overview

Note: LM APM is available to a limited number of customers. Contact your CSM if you’re interested in learning more.

Application traces can help you identify where in an application issues are occurring because it allows you to log information when an application is running, such as how long a request took, which components the request interacted with, and the latency introduced in each step.

For example, today you may receive an alert in LogicMonitor that your application response time is high. But which specific component of the application is to blame for the high response time? Is it a slow database query? A non-responsive service? Having access to the application traces would help you answer these questions. 

LogicMonitor’s Distributed Tracing is an OpenTelemetry-based integration which enables you to forward trace data from instrumented applications and monitor the end-to-end requests as they flow through the distributed services in you environment.

These traces are displayed in the Traces page alongside relevant metrics and contextual logs. Having access to applications’ metrics, traces, and logs all together in one view will help you quickly understand what is happening, why it’s happening, and where it’s happening, enabling you to troubleshoot more quickly and further optimize application performance.

Getting Started with Distributed Tracing

To get started with LogicMonitor’s Distributed Tracing, you’ll first need to instrument at least one application to forward application trace data as spans (operations) to a LogicMonitor OpenTelemetry Collector. Once LogicMonitor is receiving your application’s trace data, you will be able to view and investigate the metrics and operations using the Traces page.

The Traces page, showing the latency graph and table of operations.

Sending traces to LogicMonitor

There are two steps necessary to send application traces to LogicMonitor:

1. Deploy the LogicMonitor OpenTelemetry Collector on an application host to forward the application’s trace data to LogicMonitor. You can add an OpenTelemetry Collector through Exchange > OpenTelemetry Collectors > Add. See Installing an OpenTelemetry Collector.

2. Instrument your applications to emit OpenTelemetry-compliant traces. You can do this using OpenTelemetry client libraries for automatic instrumentation (recommended), or using the OpenTelemetry API and SDK for manual instrumentation. The following table provides language specific guidelines for application instrumentation:

Language Description
Java Automatic instrumentation instructions are available within LogicMonitor from Traces > Onboarding > Java > Automatic Instrumentation. See Instrumenting a Java Application
Python Automatic instrumentation instructions are available within LogicMonitor from Traces > Onboarding > Python > Automatic Instrumentation. See Instrumenting a Python Application
.NET LogicMonitor does not have an in-app guided experience for instrumenting .NET applications yet. You may refer to the official OpenTelemetry documentation for .NET to instrument your application and our documentation for forwarding traces from instrumented applications.
Go LogicMonitor does not have an in-app guided experience for instrumenting Go applications yet. You may refer to the official OpenTelemetry documentation for Go to instrument your application and our documentation for forwarding traces from instrumented applications.
PHP LogicMonitor does not have an in-app guided experience for instrumenting PHP applications yet. You may refer to the official OpenTelemetry documentation for PHP to instrument your application and our documentation for forwarding traces from instrumented applications.
Ruby LogicMonitor does not have an in-app guided experience for instrumenting Ruby applications yet. You may refer to the forwarding traces from instrumented applications.
Javascript/Node.js LogicMonitor does not have an in-app guided experience for instrumenting Javascript applications yet. You may refer to the official OpenTelemetry documentation for Javascript to instrument your application and our documentation for forwarding traces from instrumented applications.
C++ LogicMonitor does not have an in-app guided experience for instrumenting C++ applications yet. You may refer to the official OpenTelemetry documentation for C++ to instrument your application and our documentation for forwarding traces from instrumented applications.

Viewing traces in LogicMonitor

Once you’ve installed at least one of LogicMonitor’s Collectors in your environment and instrumented applications to emit and forward traces, you will be able to see and interact with these traces and the operations that make them up within LogicMonitor.

1. Operations will be mapped to existing resources or new resources will be automatically created if they do not already exist. You will see trace metrics start to display at the resource-level. For the best results, we recommend that you monitor the underlying infrastructure for your applications through the proper modules (LM Cloud, LM Container, and traditional compute based infrastructure). See Viewing Traces for a Resource.

2. Services will be automatically created to group underlying resources and display service-level operation metrics. See Viewing Traces for a Service.

3. Service operations and end-to-end traces will become accessible from the Traces page in LogicMonitor, allowing you to proactively identify slow operations as areas for optimization and troubleshoot issues more quickly. See Using the Traces page.

In This Article