OpenTelemetry: An Open Source Community Driven Project
OpenTelemetry is a community-driven open-source project with the goal of making telemetry data accessible to everyone. Although it has made significant headway toward its objective, including through its Github Open Source Projects, there is still a great deal of work to be done.
Telemetry data is critical for understanding how our world works. But telemetry data is expensive and proprietary. This means that only large companies with deep pockets can afford to collect telemetry data. And even then, they often don’t share their data because it’s too costly or because they want to keep the data secret.
This makes it challenging to comprehend what is happening in the world. Therefore, we require a method to obtain this information without having to pay for it. We are creating OpenTelemetry for this reason.
OpenTelemetry serves as a fantastic illustration of a community-driven initiative that has already attained a level of success. Now, in order to scale, it requires further help.
History of OpenTelemetry
OpenTelemetry started as a project in 2019, with the first version coming online in early 2021. The goal was to create an open-source telemetry system that would be easy for developers and users. It is based on Prometheus and Grafana.
The initial idea came from the need to have a common way to collect data about how applications are being used by end-users. This includes the features they use most often, the pages they visit, etc.
In order to do this, we needed a way to collect metrics from different sources (e.g., web servers, databases, etc.) and then aggregate them into one place. We also wanted to make it very easy to add new types of metrics without having to change any code.
Because of this, we were led to the products Prometheus and Grafana because both of these solutions were created specifically to address this issue.
Opentelemetry began as a merger between two existing projects, OpenTracing and OpenCensus. The goal was to create an open-source project that would provide the same functionality as Google’s Tracely library but with more flexibility in terms of configuration options.
Why OpenTelemetry started?
In 2017, Google announced its intention to release a new tracing framework called Tracely. This new tracing framework is based on the concept of “traces,” which are small pieces of data that can be collected at various points during your application’s execution. These traces could be used for debugging or monitoring purposes.
Google also provided a set of libraries to collect these traces (called tracely-SDK). On the other hand, there were several difficulties associated with using this strategy.
For example, you had to manually configure each application component to send its traces to the server. You also couldn’t easily share these traces across multiple applications.
Google also mentioned that they would eventually release a toolkit that allows developers to automatically generate traces using the tracely-SDK. Even though it sounds like a terrific idea, we are not yet aware of when exactly this toolkit will be made accessible to us.
As a result, many people decided to start working on alternative solutions. Some of them included:
- It supports both HTTP and gRPC transports.
- It provides a simple API that may be used for obtaining traces.
- There is no requirement for manual configuration whatsoever.
How OpenTelemetry is Used Today
Today, OpenTelemetry is used by hundreds of companies, including large enterprises such as Microsoft, Facebook, Netflix, Uber, and Twitter. They use OpenTelemetry to monitor their services and understand how they’re performing.
These companies use OpenTelemetry to answer questions such as:
- What parts of our service are popular among our customers?
- Which parts of our service are not being used enough?
- Are there any bottlenecks in our system?
- Is there anything wrong with our infrastructure?
- Can we improve our performance?
Why should you care about OpenTelemetry?
OpenTelemetry is a new way to monitor your application. With OpenTelemetry, you can get insights into how your applications behave at scale. For example, you can see what happens when your application receives millions of occurrences per minute.
You can also find out if your application is leaking memory or CPU time. If your application crashes, you’ll be able to quickly diagnose why. Additionally, OpenTelemetry can be utilized in the process of code debugging.
You can also get insight into your application by examining the performance and identifying any bottlenecks, for instance.
OpenTelemetry was created as a free and public resource. This means that anyone can contribute to it.
List of Most Active & Key Contributors
Since OpenTelemetry is an open-sourced technology, different people and groups from around the world can contribute to advancing the existing tech further.
Here are some of the individuals making massive and important contributions to OpenTelemetry;
James Henshaw is the author of the original OpenTracing implementation. He is currently working on OpenTelemetry. James is also the creator of the CNCF Tracing Working Group.
Sebastian König is the main developer behind OpenTelemetry. He is also responsible for maintaining the official repository.
Erik Stenman is one of the most active members of the OpenTelemetry community. He works on the OpenTelemetry GitHub organization and maintains the official repository. Stenman is also a contributor to the CNCF Tracer Working Group.
Johannes Schäfer is another key contributor to OpenTelemetry. Schäfer is also a core team member of the CNCF.
Michael Bostock is an active contributor to OpenTelemetry and a CNCFs Tracing Working Group member. Bostock is also the maintainer of the open census library.
Facebook has invested heavily in OpenTelemetry in recent years. The two types of Facebook donations to OpenTelemetry are:
The first category consists of the core libraries. These libraries provide the infrastructure needed to build an OpenTelemetry-compatible system. This includes the following:
- Prometheus – The main library used by OpenTelemetry.
- Grafana – A visualization dashboard that displays metric graphs.
- Operators SDK – Provides tools to create operators.
The second category consists of the projects that use these libraries. These projects include:
- Prometheus Dashboard – A web UI that allows users to view metrics across multiple services.
- Metrics Server – Exposes Jaeger metrics via HTTP.
- Operator SDK – Provides tools to collect traces from distributed systems.
Google, too has seen promise in OpenTelemetry and is actively contributing to it. Google’s contribution to OpenTelemetry includes;
- Prometheus – Prometheus is the primary library for OpenTelemetry. It provides the infrastructure needed to build OpenTelemetry-compatible systems.
- Time Series Database (TSDB) – Stores metric values and their corresponding label names.
- RESTful API – Allows querying TSDB using HTTP requests.
Microsoft has been working on OpenTelemetry since 2014. Microsoft’s contribution to OpenTelemetry can be divided into four categories:
- Prometheus- The main library used by the project.
- Grafana- Visualization dashboard that displays metric graphs and charts.
- Prometheus Operator- Deploys Prometheus.
- JsonWireProtocol- Protocol used by Prometheus to communicate with its clients.
Splunk is another company that has contributed significantly to OpenTelemetry. Splunk’s contribution to OpenTelemetry can be divided into three categories:
- Prometheus – Main library used by OpenTelemetery.
- Grafana – Visualization dashboard that displays metrics.
- Prometheus Operator – Deploys Prometheus.
Datadog also contributes to OpenTelemetry. Datadog’s contribution to OpenTelemetery can be divided into three major categories:
- Prometheus Operator – Deploys Prometheus.
- Grafana Operator – Runs on top of Prometheus.
- Prometheus Client – Used by Prometheus Operator to query Prometheus.
Institutional vs. Individual Contributors in OpenTelemetry
Individuals have made significant developments and contributions to OpenTelemetry. This is the beauty of open-sourced community developments. Application developers worldwide can work in unison to create more useful, accurate, and efficient technology.
However, institutional contributors make more substantial contributions. Institutional contributors are typically large corporations, universities, government agencies, and other institutions. Their contributions usually consist of funding, research, and development. They often have a vested interest in the success of the project.
For example, they may want to see the project succeed so they can continue using it.
Some businesses also give to OpenTelemetry because they think it will help them in the future. For example, Google believes that OpenTelemetry will help them improve their own products.
Contributing to OpenTelemetry
There are many ways to contribute to OpenTelemetry. You can do this through code, documentation, or even just by spreading awareness about the project.
You can contribute to OpenTelemetry by writing new code. There are two types of contributions you can make:
If you’re interested in adding a new feature to the project, you should probably start by reading the existing codebase. Then, write your code and submit a pull request.
If you find an error in the existing codebase, you should probably try to reproduce the bug yourself. Once you’ve done that, then you should fix the problem. After fixing the issue, you should add a note to the original comment explaining why you fixed the bug. Finally, you should submit a pull request.
Who has done more for OpenTelemetry, individuals or institutions?
Individuals have made considerable contributions to OpenTelemetry. However, individuals do not have access to the same resources and tools or have the same amount of people working on a solution as institutions.
As a result, institutions have had a greater impact on OpenTelemetry than individuals. In addition, institutions have contributed significantly more money, time, and effort to the project. In fact, institutions have been responsible for most of the recent progress in the project.
Institutions like Google, Facebook, Twitter, Amazon Web Services, Netflix, etc., are all contributors to OpenTelemetry. They have provided significant funding and resources to help drive this open source community-driven project forward.
Is TelemetryHub the Right Choice for You?
Telemetry Hub is designed to help you get started quickly. With Telemetry Hub, you can start collecting telemetry data from your applications today. To fulfill our promise to make this procedure easy, we will continue to refine our documentation and tutorials.
What TelemetryHub can do
Collecting telemetry data from your application is one thing. But what good is it if you don’t know how to analyze it? That’s where TelemetryHub comes in.
With TelemetryHub, you can easily visualize your telemetry data and create dashboards to monitor your application performance. You can even use TelemetryHub to generate reports based on your collected telemetry data.
How does TelemetryHub work?
TelemetryHub uses Prometheus to collect telemetry data from your app. Once the data is collected, it is stored in a Time Series Database (TSDB). The TSDB stores all the telemetry data along with labels describing each data piece. These labels are then used to build visualizations using Grafana.
Why should I use TelemetryHub?
TelemetryHub provides an easy way to collect telemetry data. It helps you understand how your application performs under different conditions. You can also use TelemetryHub to monitor your application performance over time.
The advantages of using TelemetryHub
- Easy to setup and deploy
- No need to write code to collect telemetry data
- It can be deployed in minutes
- Doesn’t require any additional dependencies
- Supports multiple language programs, including Java, Python, Go,.NET Core, NodeJS, Ruby, PHP, C#, Swift, Objective-C, Rust, Elixir, Haskell, Erlang, Scala, Clojure, and Perl
Who can benefit from using TelemetryHub
Anyone who wants to collect telemetry data about their application. This includes developers, product managers, operations teams, DevOps teams, and anyone interested in monitoring their application’s health.
OpenTelemetry is a community-driven project that aims to provide open-source telemetry solutions for monitoring and tracing distributed systems. We believe that providing such tools will enable developers to build better software faster, ultimately leading to happier users.
OpenTelemetry has received significant support from a wide variety of contributors, including both large corporations and individual software programmers. We are thrilled to see more businesses contributing to this cause, and we applaud their efforts.
TelemetryHub provides the greatest dashboard available for use with OpenTelemetry. You will gain fresh insights that you may put to use in your applications and websites as a result of this. Simply click here to get started with your demo right away!