Grafana Tempo has had quite a year. Just eight months after it was announced at ObservabilityCON 2020, the open source tracing solution went GA. Since the Tempo team released v1.0 in June, we have ingested more than 39 trillion spans, a 26x increase from last year. We also introduced Grafana Enterprise Traces, which is powered by Tempo, to the Grafana Enterprise Stack.

OpenTelemetry is a project by the Cloud Native Computing Foundation aimed to standardize the way that application telemetry data is recorded and utilized by platforms downstream. This application trace data can be valuable for application owners to understand the relationship between the components and services in their code, the request volume and latency introduced in each step, and ultimately where the bottlenecks are that are resulting in poor user experience.

In this tutorial, we will go through a working example of a Node.js application auto-instrumented with OpenTelemetry. In our example we’ll use Express, the popular Node.js web application framework. Our example application is based on two locally hosted services sending data to each other. We will instrument this application with OpenTelemetry’s Node.js client library to generate trace data and send it to an OpenTelemetry Collector.

At Honeycomb Developer Week, I got an opportunity to walk through a couple of fun new features we’ve shipped since August and ways that we’ve been able to improve Honeycomb for you. Hearing feedback from our users and customers— through support requests, in the Pollinators community, from Twitter, etc.—helps us make Honeycomb better for you.

In this blog series, we share the application instrumentation steps for distributed tracing with OpenTelemetry standards across multiple languages. Earlier, we covered Java Application Manual Instrumentation for Distributed Traces, Golang Application Instrumentation for Distributed Traces, Node JS Application for Distributed Traces, and DotNet Application Instrumentation for Distributed Traces. In this blog post, we are going to cover.

We are living in a data world. Data describes and controls almost every aspect of our life, from the president's elections to everyday grocery shopping. Data grows exponentially and so does the complexity of applications that manage that data. We all know the recent shift to microservices and other revolutionary changes that happened in the way we design, develop, deploy and operate modern applications.

During Logz.io’s ScaleUp 2021 user conference, we announced that Unified Dashboards were coming to you soon. And now it’s finally here for anyone to try during the Public Beta. Unified Dashboards will allow Logz.io customers to analyze and filter their logs, metrics, and traces side-by-side on a single monitoring dashboard. Check out our recent blog to learn about why we built Unified Dashboards and the value they bring to customers.

Today, I found a bug before I noticed it. Like, it was subtle, and so I wasn’t quite sure I saw it—maybe I hadn’t hit refresh yet? Later, I looked at the trace of my function and, boom, there was a clear bug. Here’s the function with the bug. It responds to a request to /win by saving a record of the win and returning the total of my winnings so far. Can you spot the problem in the TypeScript? It’s subtle. Now here’s a trace in Honeycomb: Now do you see the bug?

Development is no longer a linear journey from point A to point B. As more projects shift into a state of organic growth, user feedback and constant experimentation are increasingly becoming the norm, if not the standard for engineering. “In order to support this rapid experimentation, we’re beginning to embrace new working methods and practices,” said Vinodh Ravi, Executive Director of Platform Engineering at JPMorgan Chase.

I have a good sense of how to use traces to understand my system’s behavior within request/response cycles. What about multi-request processes? What about async tasks spawned within a request? Is there a higher-level or more holistic approach?

With Kubernetes emerging as a strong choice for container orchestration for many organizations, monitoring in Kubernetes environments is essential to application performance. Kubernetes allows developers to develop applications using distributed microservices introducing new challenges not present with traditional monolithic environments. Understanding your microservices environment requires understanding how requests traverse between different layers of the stack and across multiple services.