You may have previously heard about OpenTelemetry (also known as OTel) if you have looked into improved ways of standardising different data types. In this article, we’ll delve into the key things you need to know about OpenTelemetry and how this unified standard may become the future of how logs, metrics, events and traces are all handled.
The latest Jaeger v1.35 release introduced the ability to receive OpenTelemetry trace data via the OpenTelemetry Protocol (OTLP), which all OpenTelemetry SDKs are required to support. This is a follow-up to the previous announcement to retire Jaeger’s “classic” client libraries. With this new capability, it is no longer necessary to use the Jaeger exporters with the OpenTelemetry SDKs, or to run the OpenTelemetry Collector in front of the Jaeger backend.
In this tutorial, we will go through a working example of a NestJS application auto-instrumented with OpenTelemetry. In our example we will use a simple application that outputs “Hello World!” when we call it in the browser. We will instrument this application with OpenTelemetry’s Node.js client library to generate trace data and send it to an OpenTelemetry Collector. The Collector will then export the trace data to an external distributed tracing analytics tool of our choice.
Application performance monitoring (APM) solutions were designed to catch anomalies in an application or website's backend and provide meaningful insights to rectify issues in real time. Lately, though, APM solution providers have been left playing catch-up to be more inclusive of newly emerging technologies and the operational challenges they bring. OpenTelemetry (OTel) simplifies the issues caused by the demands of modern applications.
OpenTelemetry (OTel) is an emerging industry standard that dev teams use to instrument, generate, collect, and export telemetry to better understand software performance and behavior. At Helios, we leverage OTel to provide developers with actionable insights into their code within distributed systems. We give them visibility into how data flows through their applications, enabling them to quickly identify, reproduce and debug issues in their flows.
Dear Miss O11y, I’ve been told I need to use the OpenTelemetry Collector, but I have no idea what it is, or why I need it? Should I be using it? What value does it add? What the hell am I missing?
Efficient use of observability statistics is essential to any microservice architecture. OpenTelemetry is a project supported by the Cloud Native Computing Foundation (CNCF) to enhance the observability of microservice projects. AWS Distro for OpenTelemetry (ADOT) is an AWS-supported distribution of the OpenTelemetry project specifically designed to improve the observability of AWS projects.
Splunk is all-in on OpenTelemetry, as exemplified by our native support for it in Observability Cloud, Splunk Enterprise and Enterprise Cloud’s usage of the OpenTelemetry Collector with Splunk Connect for OpenTelemetry Kubernetes, our long-term ambition to use OpenTelemetry as the main way that all Splunk Products capture data from customers’ infrastructure and applications for analysis, and our massive level of contribution to the project.
OpenTelemetry is a Cloud Native Computing Foundation (CNCF) initiative that provides open, vendor-neutral standards and tools for instrumenting services and applications. Many organizations use OpenTelemetry’s collection of APIs, SDKs, and tools to collect and export observability data from their environment to their preferred backend. As part of our ongoing commitment to OpenTelemetry, we are proud to have contributed our distributed tracing libraries to the CNCF community.
“Cloud native” – working in distributed systems using microservices and DevOps – has promised a lot, and indeed delivered a lot. Among the biggest benefits, in a cloud-native distributed architecture it’s easier and more cost-effective to scale parts of an application. When one part fails, it is less likely to impact other services and the services can still communicate with each other.
Dear Miss O11y, How is modern observability using tracing, such as Honeycomb, different from the previous distributed tracing software I'm familiar with, like Dapper, at my company? I haven't really been able to wrap my head around Dapper. Does "advanced" observability mean that it's even more complicated than Dapper is? Auntie Alphabet.
Greetings friends, one and all! Over here on the Field Engineering team, we’re often asked about tracing. Two questions that come up frequently: Do I need to sample my traces? and How do I sample my traces? The folks asking are usually using tracing stores where it’s simply not possible to store all of the traces being generated. Those are great questions and the answers depend on a few different factors.
OpenTelemetry is a set of APIs, SDKs, tooling, and integrations that are designed for the creation and management of telemetry data such as traces, metrics, and logs. One of the main components of OpenTelemetry, or OTel for short, is the OpenTelemetry Collector. The OpenTelemetry Collector, or Otel Collector, is a vendor-agnostic proxy that can receive, process, and export telemetry data.
Properly leveraging telemetry is a true game-changer for any IT department looking to optimize and stabilize its systems. Telemetry provides the first step to answering the all-important question, “What’s happening in my network?” It’s your eye into the inner workings of your system, giving you a view into how different components are performing.
The recent release of Grafana 8.5 marks the start of enabling the jump from traces directly to Splunk logs. It’s a big leap that now allows you to draw a straight line between your traces — whether they are coming from Tempo, Zipkin, or Jaeger — to even more third-party logging data, all from the comfort of your traces view. Previously, the Grafana trace to logs enablement included only Loki logs.
Application Monitoring, or Application Tracing, is an important piece of Observability within your application and stack. Application tracing involves installing an API and/or SDK in your application which then instruments, or wraps your application code with other code that measures the time spent in certain areas of your code, and adds important contextual information to the traces.
In a previous blog post, Adam Quan presented a great introduction to setting up observability for a Spring Boot application. For metrics, Adam used the Prometheus Java Client library and showed how to link metrics and traces using exemplars. However, the Prometheus Java Client library is not the only way to get metrics out of a Spring Boot app. One alternative is to use the OpenTelemetry Java instrumentation agent for exposing Spring’s metrics directly in OpenTelemetry format.
As more organizations adopt cloud-native technologies and microservices-based architectures, application troubleshooting is becoming increasingly complex. With so many moving parts in an environment that is both dynamic and distributed, it is difficult to get the full picture. Yet complete visibility is crucial in order to find and fix issues quickly — especially ones that impact the bottom line.
Grafana Tempo 1.4 has been released and features a new optional component: metrics generator, which automatically generates RED metrics and service graphs from your traces. We’re actively rolling out the metrics-generator service to our own Grafana Cloud offering and are looking for Grafana Cloud Traces customers wanting early access. If interested, you can email our support team for more details.
