Sumo Logic ahead of the packRead article
Complete visibility for DevSecOps
Reduce downtime and move from reactive to proactive monitoring.
While many of the popular tools for observability in software are open source, one thing they lack is open design. Most of these solutions, from Nagios to Prometheus, started as a product with an opinionated design, which happened to work well for many people. These became the de facto standards. That position of de facto standard is what every open-source project and every commercial product tries to be.
The word "open" does a lot of work here. Open source, open design, open telemetry: but what do we mean by open design? Open design doesn't start with an opinion; it starts with a conversation. An open standard takes a lot of time to develop and requires hearing from many people to understand many kinds of use cases and perspectives.
OpenTelemetry is a solution built in the open. The history of OpenTelemetry is rooted in two prior projects, OpenCensus, which focused on metrics collection, and OpenTracing, which focused on tracing, both of which owe their origins to Google (Census and Dapper, respectively). These two projects merged to become OpenTelemetry, which seeks to unify the collection of metrics, tracing, and logs into a single system.
This unification of the different types of observability data could only happen late in the history of observability. Previous de facto standards were good at handling one kind of telemetry at a time — metrics, tracing, etc.— but these standards rarely worked together to coordinate various observations. Users had to integrate disconnected tools, and everyone approached this differently.
OpenTelemetry's vast array of existing integrations is a strength. There are already hundreds of integrations built around OpenTelemetry, including most of the major services you'd want to observe.
All of this comes together to provide a compelling user experience around observability. With OpenTelemetry, you can collect and ingest all types of telemetry using a single technology and handle each with best-in-class tooling. Instead of choosing between logs, metrics, or traces, you can bring them together under a single pane of glass. This dramatically simplifies the user experience of running complex real-world observability workloads, but that is not the unique quality that makes OpenTelemetry important.
What makes OpenTelemetry unique is how the unified design was achieved through open conversation, open governance, and the many decades of wisdom and experience from those involved in that conversation. Decades of previous open source efforts shape the process of implementing integrations for this new model.
What's needed is a design that brings everything into a single standard. And that design could only happen through public conversation and experience, where we have a good enough understanding of the range of needs.
In this case, we saw two mature projects, OpenCensus and OpenTracing, do what rarely happens in the Open Source world – merge and evolve their designs and teams into a unified project. While this is impressive technologically, it’s more impressive as a feat of human-to-human collaboration. Instead of competing and diverging, they chose to join forces and create something more significant than either project. The resulting product of that collaboration proves that it is a winning strategy.
OpenTelemetry brings portability to your observability implementation. Vendors have a vested interest in building technology that only works with itself. It locks you into their platform, making leaving difficult because you'd have to rebuild your observability infrastructure to change vendors. That's not a choice to make lightly, and it carries a measurable cost!
OpenTelemetry, specifically, the adoption of OpenTelemetry as a standard, breaks down those walls. As a customer of one of the many OpenTelemetry-based vendor products, you can easily move to another vendor and bring all that work with you rather than starting over from scratch every time. You can also more easily work with multiple vendors at once through the common bus of OpenTelemetry. That means you can get the best of all worlds rather than making compromises by choosing one vendor over another, making these products better and your life easier as a customer.
Another essential aspect of OpenTelemetry is that it is entirely open source and benefits from a vast community of independent developers and bought-in vendors who are busily building solutions and sharing that for free. By comparison, if you need help with the DataDog agent or want it to do something differently, the only people you can ask about that is DataDog. But with OpenTelemetry, you can ask anyone in the community for help.
Because it's open source, if you need to change its behavior you can modify it and submit a patch when you're done. In fact, with OpenTelemetry's very flexible decomposed architecture, it's easy to fit custom solutions into it without the need to change the other parts of your system.
As with any solution that involves custom code, security is a core concern and OpenTelemetry has been built with that in mind from the start. For example, OpenTelemetry includes support for secure transport protocols like HTTPS and gRPC-TLS, and provides mechanisms for securing sensitive data like authentication tokens and encryption keys.
OpenTelemetry is something that our industry has sorely needed for a long time now. It's finally coming into its own, with most major vendors building it into their products. It comes from a place of wisdom but also one of audacity. OpenTelemetry shows that building an observability solution in the open, based on public conversation rather than opinionated craftsmanship, will ultimately create something better and more valuable than any single vendor's product.
OpenTelemetry humbly suggests that an open standard will be better and more effective than the existing de facto standards and will upset that position in the most gentle, compassionate and graceful way possible. And it has.
We are excited about OpenTelemetry and eager to continue supporting it on our platform. We've built our distribution of the OpenTelemetry collector to ingest logs, metrics, and traces into Sumo Logic. We are bringing first-class support for this to Sumo Logic's web-based experience.
If you’re ready to get started, follow this guide to using the common OpenTelemetry demo application with Sumo Logic and read our guide to OpenTelemetry
Reduce downtime and move from reactive to proactive monitoring.
Build, run, and secure modern applications and cloud infrastructures.Start free trial