Sentry + OpenTelemetry

[AbhiPrasad]

GA 22nd February, 2023 🥳

• GA Blog Announcement
• Sentry OTel Landing Page

Sentry is an open source company, and so we're a big fan of open standards as well. OpenTelemetry is a standard for observability data (metrics, traces, logs) that we've been keeping an eye on for a while, and now we want to take the steps to better integrate Sentry with the OpenTelemetry ecosystem.

Our goal: to make it as easy as possible to get OpenTelemetry data into Sentry.

We'll be primarily focusing on getting OpenTelemetry's spans and traces into Sentry's performance product, but that's just the start!

One of Sentry's biggest advantages is that we use an agentless approach. No need to configure separate infrastructure to add an agent or collector for your application's telemetry data. We want to do the same thing with OpenTelemetry - just install and configure an OpenTelemetry and Sentry SDK in your application and we'll take care of getting that data into Sentry.

Installation is simple - add Sentry's SpanProcessor to your OpenTelemetry configuration. For example, see how it can be done in Ruby below:

Sentry.init do |config|
  # ...

  # Enable trace collection
  config.traces_sample_rate = 1.0  # or use traces_sampler

  # Enable OpenTelemetry instrumentation
  config.instrumenter = :otel
end

OpenTelemetry::SDK.configure do |c|
  # ...

  c.add_span_processor(Sentry::OpenTelemetry::SpanProcessor.new)
end

We currently have support for five SDKs:

• Ruby: SDK Setup Docs
• Python: SDK Setup Docs
• NodeJS: SDK Setup Docs
• Java: SDK Setup Docs
• .NET SDK Setup Docs
• Go: SDK Setup Docs

We want to hear from you!

If you have any questions or feedback, please email us at otel@sentry.io or post down below.

[fpacifici]

@AbhiPrasad is this the right place to discuss the infrastructure implications or do you still plan to open an rfc as discussed [here] ?(getsentry/develop#686 (comment))

[AbhiPrasad]

The plan is to open an RFC where we can discuss possible infrastructure implications - for now the majority of the work is sdk/opentelemetry schema-wise.

[ambition-consulting]

@AbhiPrasad how can I get the Sentry SpanProcessor (for Go) working in Opentelemetry-Collector?

[AbhiPrasad]

Hey @ambition-consulting! You don't need to rely on an OpenTelemetry collector when using Sentry, instead the sentry span processor will use Sentry's in-process transport to send directly to Sentry instead of to a collector or similar agent.

Please see our docs for more details: https://docs.sentry.io/platforms/go/performance/instrumentation/opentelemetry/

[AbhiPrasad]

Hey everyone! We've launched an alpha version of the Sentry Node OpenTelemetry SDK!

https://www.npmjs.com/package/@sentry/opentelemetry-node

docs: https://github.com/getsentry/sentry-javascript/blob/master/packages/opentelemetry-node/README.md

Please give it a try, feedback is greatly appreciated!

[seeARMS]

How can we add breadcrumbs and/or tags to the transaction created by OpenTelemetry in the node SDK?

I'm having some issues and documentation is a bit sparse, so I'm not sure if it's configured correctly: getsentry/sentry-javascript#7538

[AbhiPrasad]

Hey! Responded in the issue you opened, thanks for reaching out!

[AbhiPrasad]

Hey all, back again! We've launched an alpha version of the Sentry Ruby OpenTelemetry SDK!

https://rubygems.org/gems/sentry-opentelemetry

docs: https://docs.sentry.io/platforms/ruby/performance/instrumentation/opentelemetry/

Please give it a try, and let us know what you think!

[smeubank]

Sentry <> OTEL for Mobile

OTel has a quite a lot of support across backend languages and frameworks, but there is a growing interest to have support in mobile. Collected here is some information and thoughts from Sentry folks on OTel support for mobile SDKs. This is not on the roadmap at the moment, but we would like to get feedback.

.NET is on the roadmap, but unclear how that would extend to MAUI

• OpenTelemetry Support sentry-dotnet#2066
• No plugins so likely no advanced data

Swift

• OTel SDK: https://github.com/open-telemetry/opentelemetry-swift
• iOS oriented plugin, 3rd party
• There is some level of instrumentation such as NSURLSession

Java but works on Android

• No plugins so likely no advanced data

Android Disclaimer: For compatibility reasons, library desugaring must be enabled.

Dart, 3rd party

• No Flutter plugins likely no advanced data
• Dart feature request: Dart support ? open-telemetry/community#552

JavaScript(https://opentelemetry.io/docs/instrumentation/js/)

• No RN plugins likely no advanced data
• Maybe JS works on RN as well?
• RN feature request: Support for react-native environment. open-telemetry/opentelemetry-js#1089

[krystofwoldrich]

Based on this simple test JS works on RN. But it could be interesting also collect data from Android/iOS layers.

[AbhiPrasad]

We've shipped support for Golang!

https://pkg.go.dev/github.com/getsentry/sentry-go/otel

docs: https://docs.sentry.io/platforms/go/performance/instrumentation/opentelemetry/

Please give it a try, and let us know what you think!

[krainboltgreene]

This is the gateway for getting elixir performance on sentry, yes?

[AbhiPrasad]

Hey @krainboltgreene - we need to update our Elixir SDK to add an OpenTelemetry span processor, but yes it is a gateway for this!

[krainboltgreene]

What can I do to help?

[sl0thentr0py]

@krainboltgreene so there are several things that would need to be done to get performance tracing working with sentry-elixir. This SDK was so far handled by the community so it is not on par with what we call our Unified API for making common abstractions across all Sentry SDKs.

I will make 2 lists below, one of the bare minimum that would lead to quick opentelemetry based performance and the other more 'ideal' list where we make the SDK feature compatible in terms of performance with other SDKs.

Required

• Generalize the Envelope abstraction to also be able to send items of type transaction.
• Add Transaction and Span abstractions.
• Add a SpanProcessor and Propagator to hook into opentelemetry.

Optional

• The elixir SDK is further also missing Hub (for concurrency) and Scope abstractions but technically they can be ignored if a quick path to opentelemetry support is desired.

I will make a new issue out of this to track it in sentry-elixir. Unfortunately, this is a non-trivial amount of development work, so I can't give you very clear cut instructions on how you can contribute, but feel free to try stuff out and make a PR if you're interested and we can collaborate.

If there is sufficient interest from the community, we can also potentially prioritize me working on this as well next quarter.

[secustor]

Is it planned to supported using OTEL APIs in Javascript running in a browser as it is for NodeJS?

[AbhiPrasad]

Currently we found that there is no analog for an entire pageload/navigation transaction like we do with frontend sentry javascript transactions, so we haven't invested in this yet. This is the same reason why we haven't added mobile opentelemetry sdk support yet (android, ios).

Theoretically though you should be able to use our @sentry/opentelemetry-node span processor/propagator and make this work since it doesn't use any node APIs. Perhaps we should make this package generic 🤔.

Created a discussion to track this: getsentry/sentry-javascript#7364

[secustor]

What's difference of pageload/navigation to a normal span?

[AbhiPrasad]

Unlike OpenTelemetry's document load instrumentation the pageload/navigation spans are finished when the page hits an idle state, which we generate heuristically. We just found that the existing otel browser instrumentation wasn't robust enough compared to our instrumentation, but maybe this changes in the future!

The Sentry browser instrumentation:

1. Parameterizes route names so that frontend transactions/spans are better grouped together. (we take advantage of frontend framework routers to do this)
2. Record browser performance.mark/performance.measure automatically
3. Adds web vitals
4. Tracks the resource timing API
5. Tracks the long tasks API
6. Tracks the navigation timing API

and more!

[krystofwoldrich]

I've tried SentrySpanProcessor in RN with OpenTelemetry.WebTracerProvider and with a simple custom span example, correct Sentry Transaction are created.

• POC: Sentry Opentelemetry support sentry-react-native#2979

[AbhiPrasad]

Awesome! We probably need to then make the package just like @sentry/opentelemetry and make it agnostic to node/browser!

[cstavitsky]

@krystofwoldrich awesome that you did a proof of concept for RN! Any plans for next steps or timeline on the React Native side?

[krystofwoldrich]

There were no changes needed in the RN SDK to get this working, so if someone wants to use otel now with the RN SDK they can, there are just no docs and also no official support for the package @sentry/opentelemetry-node to work with RN, but it does at the moment.

We don't have a timeline but I've posted the steps to do in here getsentry/sentry-react-native#3180

[phackwer]

No onw is working on PHP yet?

[AbhiPrasad]

It seems like they use PHP extensions, would mean a lot of consequences for our agentless, extensionless PHP SDK.

If you're interested in us prioing support for PHP otel here, please open a GH issue in our PHP SDK repo, we can continue the discussion there!

[jameshulse]

It appears that 'automatic' instrumentation requires an extension, but there is still an option for manual instrumentation which doesn't require an extension: https://opentelemetry.io/docs/instrumentation/php/manual

I would be keen to see PHP (and especially Laravel) support from a Sentry SDK.

[AbhiPrasad]

cc @cleptric

[cleptric]

From my understanding, the way forward in PHP for Opentelemetry seems to be the use of their extension. I haven't looked at how we could hook into this yet.

@jameshulse Our Laravel SDK auto instruments a vast majority of different features, without the need for any manual instrumentation, so I'm curious which benefits you are seeing us adding Otel support for Laravel.

[jameshulse]

Also on PHP extensions, there is already the need to install one when using Sentry Profiling with PHP, so there is precedent in the Sentry stack already.

I will start using the SDK in earnest and see how far I get - I guess my ideal solution would be that my application integrates with an Open Telemetry compatible SDK so that my data can be sent to any back-end, but still plays nicely with Sentry so that I can choose to still view performance data there too. Maybe this is already possible and I just haven't gotten far enough yet with Open Telemetry to understand.

[bruno-garcia]

https://www.nuget.org/packages/Sentry.OpenTelemetry 🚀

[crui3er]

Hello. Here it's said that there are 2 options to report span events https://develop.sentry.dev/sdk/performance/opentelemetry/#span-events
But do you support any of them in .NET right now? Looks like it's not supported.

[bruno-garcia]

I think that's a very SDK specific note (that docs is for building Sentry itself, and our SDKs).
Related to how we can relate some spans with breadcrumbs. But in general OTel Spans should turn into Sentry Spans and how up in the product normally. Our SDKs might create these 'point-in-time' spans, but I believe that's only a browser thing. Not sure why/what we use that for. @AbhiPrasad would know.

[rask]

Is this OTel Collector Exporter an official Sentry exporter? https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sentryexporter

I would like to use an exporter to get data from my systems to Sentry without making my applications rely on a Sentry SDK.

[HazAT]

Yes, it is - It should work just fine.
Since our product is based on transactions there might be cases where the grouping of Spans it not exactly what you would expect.
But we are working on resolving this.

[AbhiPrasad]

Important to note that OpenTelemetry does not provide error monitoring SDKs. They do have error span events as part of the spec, but they are not as detailed as the one's the Sentry SDK provides. This will be missing if you choose not to use a Sentry SDK.

[rask]

@HazAT & @AbhiPrasad thanks! I'll try to test it out at some point.

EDIT: Are you saying that the LogRecord spec is insufficient for Sentry needs in terms of collecting error events? https://github.com/open-telemetry/opentelemetry-specification/blob/v1.22.0/specification/logs/data-model.md#log-and-event-record-definition

I'm not sure how logs/events and spans can interplay within OTel instrumentation and collection, as in could those be linked to provide a more whole image of an error that occurred or something, then mangle that in the exporter to become a "proper" Sentry event.

[AbhiPrasad]

The Sentry OpenTelemetry support does not support the logs or metrics signals, only tracing.

The Sentry errors schema collects the stacktrace, and when possible for SDKS, local variables in that stacktrace. We also have support for symbolication or applying sourcemaps in cases of deobfuscation or applying source maps so you always get a human readable stacktrace.

By being in process we get the most accurate stacktrace at time of error instead of relying on parsing logs which can be troublesome.

Everything though should get a traceId which can be used to link Sentry traces, Sentry errors and then logs and metrics in another system together.

[rask]

I see, thanks for the clarification!

[aradhya-variational-io]

Hi any progress on a rust SDK?

[AbhiPrasad]

hi @aradhya-variational-io - please open a GH issue in https://github.com/getsentry/sentry-rust and we can track the feature request!

[shawn-linx]

Hey! is python supported ?
SDK Setup Docs
leads to a 404

[AbhiPrasad]

@shawn-linx we should have fixed this redirect - give it a look now!

[thomaseizinger]

Are there any plans to support OTEL metrics in Sentry?

[AbhiPrasad]

@thomaseizinger not at the current moment

[thomaseizinger]

Has this position changed at all? It would be awesome to also use Sentry for metrics in addition to errors and logs.

[dcramer]

Not right now - focus is on core telemetry, and most metrics behaviors are already provided by spans and logs (and aggregations, which are far more powerful). It will be possible to send metrics-as-logs if you really want that in the future, but beyond that we currently have no plans to support abstract metrics.

[thomaseizinger]

Our usecase of Sentry are user-run applications and we only selectively ingest logs from them on-demand when we need to troubleshoot something.

In addition, I would like to capture metrics such as various counters which would be way too computationally expensive to compute from logs, let alone having to filter out that noise when one actually looks at the logs. We are building a networking applications, so we are talking about millions of packets / second here. Way too expensive capture in logs (in order to run aggregations) without sacrificing performance.

We could run our own otel-collector and ingest into that but exposing something like this publicly seems like a lot of infra-effort that we'd ideally like to outsource to a product like Sentry which are experts at that.

What would metrics-as-logs look like?

[kkmuffme]

Is there any simple way to integrate the OpenTracing data from nginx (https://github.com/opentracing-contrib/nginx-opentracing) to be included with Sentry?
(since nginx request processing starts before the application where we already use the Sentry PHP/JS SDK for tracing, it currently seems to be a lot of work to add the spans created by nginx to the spans we get from PHP/JS in Sentry)

[AbhiPrasad]

Hey @kkmuffme. In the future we'll be able to support OpenTelemetry based NGINX instrumentation with the OTLP endpoint we are building out.

We won't support OpenTracing, you'll need to migrate to OpenTelemetry.