In today's complex landscape of microservices, distributed systems, and AI-driven processes, understanding what's happening inside your applications has never been more critical—or more challenging. When a request slows down or an error occurs, how do you find the source? The answer lies in observability, and the combination of OpenTelemetry and trace.do provides an unparalleled solution.
Modern applications are no longer monoliths. They are intricate webs of interconnected services. A single user action can trigger a cascade of events across dozens of systems. Without a clear map, debugging becomes a frustrating game of guesswork. This is where standardized telemetry data and powerful visualization tools become essential.
This post will explore how you can leverage the industry-standard OpenTelemetry for data collection and integrate it seamlessly with trace.do to turn that data into actionable insights and understand every action within your workflow.
For years, developers relied on proprietary agents and vendor-specific SDKs to gather performance data. This led to vendor lock-in and a fragmented approach to monitoring. OpenTelemetry (OTel) changed the game.
OpenTelemetry is an open-source, vendor-neutral observability framework for instrumenting, generating, collecting, and exporting telemetry data (traces, metrics, and logs). By offering a single set of APIs and SDKs, OTel allows you to:
In short, OpenTelemetry has become the gold standard for how you collect observability data. But collecting data is only half the battle. The real value comes from making sense of it.
While OpenTelemetry provides the raw materials, trace.do is the expert craftsman that transforms them into a clear, understandable picture. trace.do is an agentic workflow designed for effortless tracing and observability, allowing you to Visualize Your Workflow with unprecedented clarity.
Instead of sifting through raw data logs, trace.do helps you:
As stated in our FAQ, a trace provides a detailed view of a request, including timing for each operation (spans), metadata, logs, and relationships between services. This is how you go from knowing that a problem exists to knowing why.
The true magic happens when you combine the open-standard data collection of OpenTelemetry with the powerful analysis and visualization of trace.do. Because trace.do is built to be compatible with OpenTelemetry, integration is seamless and delivers the best of both worlds.
Why is this integration so powerful?
Integrating your OpenTelemetry setup with trace.do is designed to be incredibly straightforward:
Imagine a request to a user profile API. The raw trace data collected by OpenTelemetry might look something like this:
{
"traceId": "a1b2c3d4e5f67890",
"traceName": "/api/user/profile",
"durationMs": 150,
"spans": [
{
"spanId": "span-001",
"name": "HTTP GET /api/user/profile",
"service": "api-gateway",
"durationMs": 150
},
{
"spanId": "span-002",
"parentSpanId": "span-001",
"name": "auth-service.verifyToken",
"service": "auth-service",
"durationMs": 25
},
{
"spanId": "span-003",
"parentSpanId": "span-001",
"name": "db.query:SELECT * FROM users",
"service": "user-service",
"durationMs": 110
}
]
}
While this JSON contains all the necessary information, it's difficult to quickly diagnose the performance.
With trace.do, this data is instantly transformed into an intuitive waterfall chart. You would immediately see:
The bottleneck is instantly visible. The db.query is consuming over 70% of the total request time. This is the kind of immediate, actionable insight that trace.do provides, allowing you to debug an order of magnitude faster.
Stop guessing and start seeing. By combining the open, flexible standard of OpenTelemetry with the intuitive and powerful visualization of trace.do, you can gain deep insights into your application's performance. Understand the complete journey of every request, pinpoint bottlenecks in seconds, and build more resilient, efficient systems.
Ready to visualize your workflow and understand every action? Get started with trace.do today and bring effortless observability to your team.