opentelemetry-specification VS Sentry

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.

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.

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 which follow the specification.

Today we learned how to manually configure OpenTelemetry for Python to connect to Lightstep (this also works for any Observability back-end that ingests the OTLP format). We also learned how to link related services together through manual context propagation.

According to the opentelemetry specification for messaging systems, When a process receives messages in a batch it is impossible for this process to determine the parent span for the span that it is currently creating.

That's why you have otel logging: https://github.com/open-telemetry/opentelemetry-specificatio...

OTLP protocol for shipping telemetry data

Lightstep ingests data in native OpenTelemetry Protocol (OTLP) format, so we will use the OTLP Exporter. The exporter can be called either otlp or follow the naming format otlp/. We could call it otlp/bob if we wanted to. We're calling our exporter otlp/ls to signal to us that we are using the OTLP exporter to send the data to Lightstep.

You can check the drone license or sentry license.

i dont like. because our systems was not worth their cost. neat features, i like sentry.io

Use external error tracking tools. I always recommend Sentry (https://sentry.io/) as it is excellent at detecting errors in real time. Whenever an error happens to a user, you receive a complete report of what happened, the type of browser used and many other insights that will help you to isolate and resolve the bug.

If you don't have any crash reporting in your app, I would recommend doing that. Something like https://sentry.io/ (no affiliation, just a happy user) can help pinpoint mysterious crashes like this. There is a video showing how to integrate sentry into your MAUI app here: https://www.youtube.com/watch?v=9-50zH8fqYA.

You can take a look at the Python codebase for Sentry over here: https://github.com/getsentry/sentry/tree/master/scripts

He made yesqa and pyupgrade (among others), and also works on flake8. His main job is for https://sentry.io/.

Checkout Sentry code

Have you heard of sentry ?

Sentry is a really big application that has done this. They turned their django app into a API layer and the entire frontend is a large react app. https://github.com/getsentry/sentry

We already had a significant amount of tests and every PR gets reviewed (https://github.com/getsentry/sentry/pulls) and this still uncovered bugs