opentracing-javascript VS opentelemetry-specification

Spring Spring web framework Spring WebFlux Reactive REST Services Spring Data R2DBC a specification to integrate SQL databases using reactive drivers Redisson Redis Java Client Zipkin open source, end-to-end distributed tracing Spring Cloud Sleuth auto-configuration for distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus Kubernetes automating deployment, scaling, and management of containerized applications Docker and docker-compose Helm The package manager for Kubernetes Flywaydb for migrations

Elasticsearch client for Go RabbitMQ Go RabbitMQ Client Library Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus Echo web framework Kibana is user interface that lets you visualize your Elasticsearch Docker and docker-compose Kubernetes K8s Helm The package manager for Kubernetes

PostgeSQL as event store database Kafka as messages broker gRPC Go implementation of gRPC Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus MongoDB MongoDB database Elasticsearch Elasticsearch client for Go. Echo web framework Kibana Kibana is data visualization dashboard software for Elasticsearch Migrate for migrations

OpenTracing was an open-source project aimed at providing vendor-neutral APIs and instrumentation for distributed tracing. In distributed cloud-native applications, it is difficult for engineering teams to see how requests are performing across services. And that’s where distributed tracing comes into the picture.

OpenTracing is now archived, and it is suggested to migrate to OpenTelemetry.

In this article let's try to create closer to real world Event Sourcing CQRS microservice using: 🚀👨‍💻🙌 EventStoreDB The database built for Event Sourcing gRPC Go implementation of gRPC MongoDB Web and API based SMTP testing Elasticsearch Elasticsearch client for Go. Jaeger open source, end-to-end distributed tracing Prometheus monitoring and alerting Grafana for to compose observability dashboards with everything from Prometheus swag Swagger for Go Echo web framework Kibana Kibana is user interface that lets you visualize your Elasticsearch

I agree; but I think it'll take years, if ever, to change this culture.

Logging is a byproduct of a past time; everything is a file, stdout is a file, lets persist that file, now we have multiple replicas, lets collect the file into a multi-terabyte searchable database.

The biggest downside: Its WILDLY expensive. Large orgs often have an entire team dedicated to maintaining logging (ELK) infrastructure. This price-tag inevitably leads to bikeshedding on backend teams about how to "reduce the amount we're logging" or "cleaning up the logs" or "structuring them to be more useful".

Outside of development, they are so rarely useful. Yet inevitably someone will say: "you're just not structuring your logs correctly." Maybe that's true; similarly, I don't find vim to be a highly productive editing experience. Maybe I just don't have the thousands of extensions it would take to make it so. Or maybe You're stuck in the past and ignoring two decades of tooling improvement. Both can be true.

I'm phrasing this as a false dichotomy, because in many teams: it is. Logging is easy; its built-in to most languages; so devs log. The information we need is in the system; its a needle in a haystack, but the needle is there. We log when a request comes in, when it hits pertinent functions, when its finished, how its finished, the manager says: "just look at the logs". Instead of "what better tooling can we make an investment in so future investigations of this nature don't take a full day."

For starters: Tracing. Tracing systems should be built-in to EVERY LANGUAGE, just like console.log. We have a standard [1] sponsored by the Linux Foundation and supported by every major trace ingestion system. This is not a problem of camps and proprietary systems; its a problem of culture. I should be able to call a nodejs stdlib function at startup, specify where I want traces to go, sampling rate, etc, and immediately get every single function call instrumented. Its literally just highly-structured-by-default logging! Dump the spans to stdout by default! Our log ingestion systems can read each line, determine if its a span, if so route to trace ingestion, otherwise route to log ingestion.

This is a critical step because it asserts that tracing is actually a very powerful tool that everyone needs to learn, like logging. Everyone knows about logging. Why? console.log. Its there, it gets used. Tracing right now is relegated to a subculture of "advanced diagnostics"; you gotta adopt a tracing provider, bring in dependencies, learn each implementation of OpenTracing, authenticate to send traces over HTTP... as a community, we should normalize just "dump traces like you dump logs, to stdout", have a formatter to make them nice to use in development, and now all that instrumentation work that any dev is capable of utilizing (just like console.log) "just works" in production.

[1] https://opentracing.io/

Service mesh - ssup2ket services run on service mesh for detailed traffic control and easy monitoring. Service mesh is applied through Istio. Istio uses OpenTracing for easy request tracing between multiple services.

It means that the OpenTelemetry project provides not only a specification to define the contract between the applications, collectors, and telemetry databases, but also a set of APIs, SDKs, and tools like instrumentation libraries (for different languages), collectors, operators, etc. OpenTelemetry is open-source and vendor-agnostic, so the project is not tied to any specific vendor or cloud provider.

Sure, happy to provide more specifics!

Our main issue was the lack of a synchronous gauge. The officially supported asynchronous API of registering a callback function to report a gauge metric is very different from how we were doing things before, and would have required lots of refactoring of our code. Instead, we wrote a wrapper that exposes a synchronous-like API: https://gist.github.com/yolken-airplane/027867b753840f7d15d6....

It seems like this is a common feature request across many of the SDKs, and it's in the process of being fixed in some of them (https://github.com/open-telemetry/opentelemetry-specificatio...)? I'm not sure what the plans are for the golang SDK specifically.

Another, more minor issue, is the lack of support for "constant" attributes that are applied to all metrics. We use these to identify the app, among other use cases, so we added wrappers around the various "Add", "Record", "Observe", etc. calls that automatically add these. (It's totally possible that this is supported and I missed it, in which case please let me know!).

Overall, the SDK was generally well-written and well-documented, we just needed some extra work to make the interfaces more similar to the ones were were using before.

OpenTelemetry is an open-source collection of tools, APIs, and SDKs that aims to standardize the way we generate and collect telemetry data. It follows a specification-driven development. The OpenTelemetry specification  has design and implementation guidelines for how the instrumentation libraries should be implemented. In addition, it provides client libraries in all the major programming languages that follow the specification.

Two problems with OpenTelemetry:

1. It doesn't know what the hell it is. Is it a semantic standard? Is a protocol? It is a facade? What layer of abstraction does it provide? Answer: All of the above! All the things! All the layers!

2. No one from OpenTelemetry has actually tried instrumenting a library. And if they have, they haven't the first suggestion on how instrumenters should actually use metrics, traces, and logs. Do you write to all three? To one? I asked this question two years ago, not a single response. [1]

[1] https://github.com/open-telemetry/opentelemetry-specificatio...

OpenTelemetry Specification GitHub

One update to this: we proposed replacing the count suffix in OpenTelemetry with total to match Prometheus/OpenMetrics. That discussion resulted in the count suffix being removed from the OpenTelemetry semantic conventions. We'll soon update our metric from being called function.calls.count to just function.calls and the generated Prometheus queries will refer to function_calls_total. That resolves one of the main conflicts between the two specs.

This is your best bet if you want to track status updates: https://github.com/open-telemetry/opentelemetry-specification/issues/2911

OpenTelemetry is a standard for implementing telemetry in your applications. It provides a specification, containing the requirements that all implementations should follow as well as some implementations for major languages, including an API and a SDK to interact with it.

At this point, we are about to do the real work where we have to configure OpenTelemetry and export telemetry data to New Relic. Exporting this kind of data relies on a specific protocol; the OpenTelemetry Protocol or OTLP.

OpenTelemetry provides instrumentation libraries for your application. The development of these libraries is guided by the OpenTelemetry specification. The OpenTelemetry specification describes the cross-language requirements and design expectations for all OpenTelemetry implementations in various programming languages.