Logs in Sentry 🚀 - Open Beta

[Dhrumil-Sentry]

TL;DR

Sentry is adding support for structured logs, so you can view and query your logs alongside your traces and errors—all in one place.

You can find the SDK instructions to send logs here:

JavaScript SDK instructions here.

Python SDK instructions here.

See other supported SDKs here

Just head to Explore->Logs to view your logs !

We're working on supporting more SDKs and will keep this discussion updated as we iterate. For more details, keep reading or join the discussion below!

---

One of the biggest asks we've heard from our users is that you'd like to have the ability to send logs to Sentry, to have a single pane of glass for all your observability needs.

For those of you that have been with us for a while, you know we've always had some opinions about logging and how we’re focused on errors-first troubleshooting. However, we recognize that for many developers, log statements often provide valuable context for identifying and correcting problems.

To that end, we're happy to announce that we're adding support for logs in Sentry. Soon, you'll be able to send logs to Sentry and view them alongside traces & errors.

Read more details on how we're implementing support for logs, the "Sentry way" (or, if you'd like, Sentry's version). ⬇️

What can you do with Logs in Sentry?

• View logs from across your application: Use our new Log Viewer to search and filter your application logs based on any attribute.
  
• Find relevant logs when debugging errors: View logs in context directly from an error in Sentry to quickly understand what led to the issue.
  
• (Coming Soon) Aggregate and analyze log patterns: Slice and dice logs to monitor patterns, unusual events, or any key behavior in your app. You can visualize these patterns in dashboards or set up alerts based on log data.
  

Why Logs in Sentry?

When debugging, logs, traces, and errors work better together. Logs provide the granular context—like retries, API failures, and internal state—that spans and errors can miss. But in most tools today, logs live in a separate system, forcing you to switch between tools to piece together the full picture.

With logs in Sentry, everything is in one place. You can see logs right alongside your errors and traces—no more context switching, just faster debugging.

Getting started is just as easy as adding a console.log or logger.info. Our SDKs handle the heavy lifting, automatically linking your logs to traces and errors so you get the full context with minimal setup.

Also - We're supporting structured logging that will support passing variables in a string template directly - We'll extract your variables and the template as attributes of the log that you can query

Supported SDKs: What’s Available and What’s Next

We’re kicking things off with JavaScript (including TypeScript and frameworks like NextJS, etc), and support for Python will be available in the next two weeks. More languages will follow as we expand logging support across our SDKs.

We’re also working on seamless integrations with popular logging frameworks. That means no major rewrites—just flip a switch at the SDK level, and your logs will start flowing into Sentry alongside your traces and errors.

Try Logs in Sentry

Just head to Explore->Logs to view your Logs. You can get started with sending Logs by following SDK instructions here

We'll be actively adding support for more SDKs over the coming weeks, but if you want to see a specific SDK prioritized, please leave a comment!

What Feedback Are We Looking For?

• Does the log search experience meet your needs?
• How easy was it to get set up?
• Are there specific features or capabilities you’re missing?

Your input will help us refine our Logs as we work towards general availability.

Drop your thoughts below, or email us directly at [email protected]. We’re looking forward to hearing from you!

[tcurdt]

For us search isn't really that super important. Triggering alarms would be the main thing we would be interested in.

[Dhrumil-Sentry]

@tcurdt thanks a lot for this feedback - Would love to understand what type of aggregate queries do you write on top of Logs

[tcurdt]

TBH ... we tweak our our logs so that ERROR really means error. We try to log as little as necessary.
What would be nice if types log lines could be automatically (or semi automatically) be grouped.

"something happened to [foo]"

So all except what is in between [] could contribute to the grouping fingerprint.

"something happened to [*]"

That would be the aggregating I could imagine. And that's also what could be used for the basis of different alarm triggers.

[Dhrumil-Sentry]

Thank you for sharing these details - We're going to support structured logging - so you will have access to the template you used to log in your code as a searchable attribute too and you should be able to write a query that gives you the count of logs matching that template over a time interval and alerts would be supported too - We're just a few more weeks away from enabling that but we def plan to have it when Logs become generally available 😄

[JoshFerge]

could you add the org joshys-testing-stuff to the beta? 🙏🏼 <3

[zleight1]

Hi, looking forward to seeing what you do with this feature 🤩 !

Can you add this to our org torq-dp?

[Dhrumil-Sentry]

@zleight1 We'll add you org when we roll this out and will drop a note here too

[carolineartz]

looks great! Interested in the beta :) cutover-pg org

[Dhrumil-Sentry]

@carolineartz We'll let you know once we release it for you, Would love to understand how you search logs today? Do you search by attributes of a structured log or do you use wildcard matching over the entire message

[RationalRank]

Will you support mobile SDKs in the future? If so, will you also consider processing everything on-device, and allow us to configure settings such that logs are pushed only when there's an error, and not simply push all logs to Sentry?

Use case: When there is an Exception captured by Sentry, I would see a consolidated list of breadcrumbs + logs to get the full picture. Right now, we have a breadcrumbs section, but a combined view would be great.

Example:

• java.lang.NullPointerException: null
  • LOG: W: Order does not have an ID
  • BREADCRUMB: HTTP call
  • BREADCRUMB: User clicked order
  • BREADCRUMB: App lifecycle - Launched

[Dhrumil-Sentry]

@RationalRank We will support Mobile SDKs as a quick follow up once we launch for JS and Python. Also we're planning to gradually consolidate breadcrumbs and logs but that's a longer term effort for us once logs are generally available so users will get a consolidated view.

We plan to support SDK APIs to allow for client side filtering of logs but we don't have plans to support sending logs only when there is an error - Is your main reason to control the volume of logs you send to Sentry?

[RationalRank]

@Dhrumil-Sentry Yeah, that's right

[jtmaveryk]

Can’t wait, always wish this was integrated, it’s really an AIO now! Would love to participate in the beta (airplo) 😊

[Dhrumil-Sentry]

@jtmaveryk - Thanks for the interest! Any must-have use cases or capabilities you'd like to see in Logs?

[jtmaveryk]

Nothing that you guys haven't already thought of, haha. The logs would be a crucial part helping link errors to issues/events.

[talas9]

Hi, could you add skycrew please? we are very interested in testing this in JS and Python

[Dhrumil-Sentry]

@talas9 Will def add you in and let you know soon - Would love to understand if you write custom log query based alerts today already ? Or are you mainly interested in search and seeing errors and all related logs together?

[talas9]

I don't have any retention implementation at the moment, some projects are GCP and some are on Heroku so might be good to have the ones on Heroku handled professionally

[zhiyan114]

I'd love to try out logging as well @ furrynet

Perhaps, some kind of pattern matching (regex?) alert would be really useful.

[Dhrumil-Sentry]

@zhiyan114 Thanks! Would love to understand what type of regex queries do you run - We're going to have support for wildcard matches similar to a contains operator and iterate.

[zhiyan114]

I'm thinking something like [Log]: Error Code {1 to 128} where we might only want to send a notification if the error code is between 1 to 64, for example.

In this case, instead of writing multiple notification conditions, we could use \[Log\]: Error Code (?:[1-9]|[1-5][0-9]|6[0-4])\b to filter it. Though, I think there's probably more efficient way to do this than using regex.

[Dhrumil-Sentry]

@zhiyan114 Thanks for sharing this use case. We're going to be supporting structured logging - So you can just log like this

Sentry._experiment_log.info(fmt user ${username} just bought ${item}!);

And Sentry would store the template and the username both as attributes in your log and you can directly query for these attributes

[edgariscoding]

This is awesome! Very happy to see logging added to Sentry!

[joshdales]

Could pockethealth please be added to the beta 🙏 Would love to try this out

[Dhrumil-Sentry]

@joshdales - Thanks a lot for this detailed feedback ! - we're going to addressing a lot of these soon and adding the ability to view count of logs as a chart too in that page

[AbhiPrasad]

It would be nice if the user id (maybe other user data but really at least that) from when we called Sentry.setUser could be included in the log, currently I'm just adding that property myself which is fine but it would be nice if there was a global setting that I could include for all logs so that I didn't have to pull in the logic to get that.

We're working on adding defaults attributes for logs like user id, browser, and device. For now you'll have to set it yourself until we define what the defaults should be for every platform we support, but we'll definitely make this easier for you!

If you want to add this to every single log but define it once, you can define a beforeSendLog function. JavaScript example:

Sentry.init({
  _experiments: {
    enableLogs: true,
    beforeSendLog: (log) => {
      log.attributes = {
        ...log.attributes,
        'user.id': getUserId(),
      };
      
      return log;
    }
  }
});

[joshdales]

Nice - would the chart apply to searches?
Just that I generally use the message field like this commonNameForLibOrFeatureOrSomething.entityThatWeAreDealingWith.actionBeingPerformed, so in your example rather than doing this:

Sentrylogger.info('Adding item to cart', { item: 'sneakers' });
// later
Sentry.logger.error('Failed to purchase item in cart', { item: 'sneakers', ...err });

We do

Sentry.logger.info('cart.add', { item: 'sneakers' });
// later
Sentry.logger.err('cart.purchase', { item: 'sneakers', ...err });

So that if I wanted to search for everything related to the cart I can just do log.body is "cart.*" or even log.body is "cart.*"|log.severity_text is "error" and get the count for how cart based events, or cart errors happened?

[Dhrumil-Sentry]

So that if I wanted to search for everything related to the cart I can just do log.body is "cart." or even log.body is "cart."|log.severity_text is "error" and get the count for how cart based events, or cart errors happened?

Yes - it will apply for searches too! That's exactly what we're building

[joshdales]

Amazing! Looking forward to it

[liamjones]

This is really nice to see.

Is this feature intended to only collect logs from the things integrated with the Sentry SDK? Or are there plans to ultimately support log shipping from other sources into the Sentry UI, too?

[Dhrumil-Sentry]

@liamjones - We're starting with logs collected from the Sentry SDK, would love to understand what other sources did you have in mind?

[liamjones]

@Dhrumil-Sentry It wasn't anything particularly concrete; I was just thinking about things that might be useful as extra context when investigating issues.

For instance, a scenario where we have a Sentry application that depends on another application which cannot be integrated with Sentry, such as a closed-source third-party app. In such cases, it would be potentially useful to have access to the logs of the closed-source application or the slow query logs of the database that the application utilizes.

[gg-kialo]

It would be ideal if sentry were a fluentbit output, so I can just change the fluentbit config and get all my logs cluster wide sent to sentry with no application changes.

Only having first-party application logs in sentry would be a real let-down. That would split my logging across two systems. I can barely remember the query syntax for the logging system I use as it is.

[Dhrumil-Sentry]

Thanks a lot for this feedback - Currently, we're focussed on building an application logging solution that is connected to all other telemetry - errors, spans, replays etc via our trace id so developers get the full context needed for debugging their code.

We may support such generic sources in the future but that is not something we're prioritizing until we're able to make these Logs generally available to all our users.

[wichopy]

Please let me know if we can get some access at the slug qliktechnologies :)

[Dhrumil-Sentry]

@wichopy - We'll def enable this for your org as well - Stay tuned for an update sometime next week 😄

[gasparbrogueira]

Will it also be available in a self-hosted version?

[Dhrumil-Sentry]

Yes it will, You might find this issue in the self-hosted repo helpful: getsentry/self-hosted#3560

[fmod-andrew]

Sounds great! Can we use it from sentry-native? 🙏

[Dhrumil-Sentry]

Hi @fmod-andrew - We will be rolling out support for more SDKs including sentry-native but we don't have concrete timelines for that yet

[fmod-andrew]

Keen to help out testing early sentry-native support when the timelines firm up. Slug = firelight-technologies

[weedgrease]

would love to try this out with our team! proofteam is our slug ❤️

[AbhiPrasad]

If you're interested in log drain support, please reach out via this GitHub issue. Thanks!

[abhi-fwd]

I don't see any details on the pricing. I would love to have a unified view across Sentry and our logs. But I can't make the case for it without knowing the cost.

[Dhrumil-Sentry]

@abhi-fwd - We'll likely be in open beta for 2-3 months and there is no cost to try it and evaluate fit.

We're still finalizing pricing and packaging details - but we'll have a free amount of volume for all our plans. We will share updates when we have more details 🙏

[DirkLachowski]

@Dhrumil-Sentry As someone looking into Datadog logging because we use a lot of Datadog's tools, the price is one of the most important factors to decide. As you already wrote, there's a ton of log aggregators - and most do mostly the same. In the long run, we'll focus on one tool, sentry or DD.

Currently, if we fully switch to DD and spend our sentry business plan fee there, we'd get error tracking and could log 35m log lines / month for that fee. So, for sentry to be competitive, I'd expect that as the lower bound for the monthly free amount. Any chance that that could be the sweet spot?

[Dhrumil-Sentry]

Hi @DirkLachowski - thanks for the question, We're discussing these packaging details and we're more likely to price by Gb vs log lines and it's not going to be an ingested/indexed type of charge either.

So how many log lines you can send under the free tier would depend on the avg size of your logs. If all of your logs are 1-3Kb you could send 10M-30M log lines but we're still finalizing these details.

I'd love to understand if there's anything else you'd like to see in Sentry to consolidate with us

[dwolrdcojp]

Will there be an API released with this as well? We have a Zig backend server that will likely never have an SDK made.

[AbhiPrasad]

Hey @dwolrdcojp!

We have a Zig backend server that will likely never have an SDK made.

Can you use our native SDK? https://github.com/getsentry/sentry-native. Logs support for native is being tracked here: getsentry/sentry-native#1210

Otherwise we do have an endpoint you can send logs to, but it uses our custom envelope format instead of JSON. You can see more details here: https://develop.sentry.dev/sdk/data-model/envelopes/
The log envelope item is documented here: https://develop.sentry.dev/sdk/data-model/envelope-items/#log

We also have a complete spec of how to implement logs in an sdk, for any language: https://develop.sentry.dev/sdk/telemetry/logs/. This also provides some examples for sending logs via envelopes.

[savvasdalkitsis-dojo]

Is there any reason the Logs option would not be available on the UI? I see the plans above didn't mention Enterprise. Are logs not available for Enterprise plans?

[Dhrumil-Sentry]

Yes, that's correct - Logs are not available for Enterprise customers since this is in Beta and actively being worked on. But please feel free to reach out to your CSM and we can enable it for your org if your team really wants to try it out.

[lesderid]

How long are logs retained for?

[Dhrumil-Sentry]

@lesderid - While in the Beta, we are allowing querying Logs for the last 14 days. But we plan to make this 30days as sprint towards general availability in a few months

[olejorgenb]

I would prefer to be able to pay to keep them for longer

[dmitrivi]

Is there going to be an option to store logs for 12 months or longer?

[alphatownsman]

with this in django's settings.py, logs from loguru do not show up in sentry's logs, but errors from loguru logs are tracked in issues properly.

Is there anything I missed?

    sentry_sdk.init(
        dsn=_SENTRY_DSN,
        integrations=[
            DjangoIntegration(),
            LoguruIntegration(event_format="{name}:{function}:{line} - {message}"),
        ],
        _experiments={"enable_logs": True},
    )

[AbhiPrasad]

Hey @alphatownsman we don't support loguru in our Python SDK just yet! We are tracking support for this here: getsentry/sentry-python#4151 - please subscribe to that issue so you'll get notified when we add support for this to the SDK!

[AbhiPrasad]

We've released support for Loguru in 2.30.0 of the Python SDK! Please give it a try.

[deanbiltup]

Need something more like MDC. In our case, server-side, we use asyncLocalStorage.set('userId', userId) and 'clickId' from http header from GUI and 'companyId', and svrTxId and so much more.

ALLLLL of our logs are simply log.info("some test"); and behind the scenes the logger reads in the context(in java, you can google MDC). In typescript, asyncLocalStorage is used to sneak context past to wire up the call into GCP logging.

So on GCP, we simply RIGHT click a [email protected] (userId) in some log and choose 'show mathcing entries' and it filters all logs to that user OR BETTER, we use clickId to see his one transaction.

spanIds are not always there so we could never use that. I still need to debug how spans work as I believe there should always be one(when one span ends, another shoudl begin but does not with angular sentry). We invented clickId as the closest thing in angular changing every time there is a click event, tab event or enter event as the main things for OUR application as this is 99% true in a business app but not a gaming app where mouse move may trigger, etc. clickID for us always exists as first page load, we set it to something and after that it swaps only with clicks.

Anyways, GCP is far better than sentry logging here though it would be GREAT if sentry did this client and server so you could click clickId and see all server and client logs in line and in order. Currently, we just swap between each.

[Dhrumil-Sentry]

Thanks a lot for this feedback, we're definitely going to think over this one a bit more because the use case is 100% valid.

Currently the workaround we have is that each SDK has a beforeSendLog() method where users can attach any attribute they want to their logs before they are sent to Sentry.

[AbhiPrasad]

I still need to debug how spans work as I believe there should always be one(when one span ends, another shoudl begin but does not with angular sentry)

there might not always be a sampled span available - but there should always be a trace that we attach to all outgoing logs. That allows you to see all related logs for a single pageload for example. You can search trace in the logs query to find this.

[deanbiltup]

I was doing getTrace or something to send to server and it was sometimes null I recall so I gave up and created my own clickId that was 100% reliable since it is in a static variable that only changes values and never goes to undefined. For some reason, trace would be undefined when I fetched it to put in http header to send to server so that I could then Sentry.setTag('ourTrace', clientTraceId) so I could try to link them. this failed so I gave up. I tried to not re-use the sentry tag to avoid collisiion there too.

[zip-fa]

is it possible to implement some api to send logs from vector? https://vector.dev/
Would like to see more integrations to send all the logs from multiple sources at once.
My use-case is to grab logs from docker containers (stdout+stderr) with vector and send them to sentry at once without implementing logging from many backend services, many frontend applications etc.

[Dhrumil-Sentry]

We're tracking requests for log drains here: #91726

Our main focus for the next couple of months is product UX improvements and improved support from our SDKs which can add trace ids, span ids etc to all relevant logs allowing us to connect errors, traces and logs in a good workflow in the UX.

[AbhiPrasad]

I created a separate GH issue in #92400 to track this feature request. Could you leave more details about what you would want out of Vector support there?

One issue with solutions like vector is that you won't get context like trace_id, release, and environment linked to your logs. This makes it much harder to connect logs to errors, traces/spans, profiles, and/or session replays in Sentry. Without this connecting context, tooling like Seer Autofix becomes much less useful.

[Syed-RI]

We have a .NET MAUI Project and would like to opt into the Beta to explore. Is there any way this can be requested ? @AbhiPrasad @jamescrosswell

[AbhiPrasad]

All Sentry users on the developer, team, and business plans should have access to the logs beta. We currently support a bunch of different SDKs including JavaScript/Node.js, Java/Android, Dart/Flutter, Python, Ruby, and Go.

We're actively working on the implementation for .NET - subscribing to the tracking issue getsentry/sentry-dotnet#4132 will allow you to see the moment it's released.

For .NET MAUI, we need to add mobile support as well. We already have Android support, and are tracking iOS support in this GH issue: getsentry/sentry-cocoa#5122

[dogweather]

What are the current languages supported?

[Dhrumil-Sentry]

We support Python, JS, Ruby, Go, Android, Java and support for more SDKs is coming soon - You can find more info from these docs: https://docs.sentry.io/product/explore/logs/getting-started/

[Meditatingpanda]

@Dhrumil-Sentry, is there a way to override , Sentry logger to pick up rails logger logs as well?

[AbhiPrasad]

@Meditatingpanda I recommend opening an issue in https://github.com/getsentry/sentry-ruby/issues describing your use case and app. The Ruby SDK maintainers can help you here.

[mimre25]

To me it would be a cool feature if only the last n minutes/seconds or the last n logs before an error are collected.

Ie, on client side cache the logs, and only send them to the server if an error (or event) happens. Alternatively, retain only the logs on the server that are "close" to an error.

This would really reduce the load on self-hosted instances.

[AbhiPrasad]

Hey @mimre25 we currently don't have plans for functionality like this at the current moment. In the future we might explore more complex sampling strategies for logs like what you've mentioned.

You can probably leverage beforeSendLog/before_send_log options to try to simulate something like this in the time being.

[mimre25]

Yeah I thought so too that I could do it that way - will post back in case I go this route so others can benefit from it.

Thanks for the quick reply!

[cthier-eb]

Logs were working smoothly until 17th of may when they suddenly stopped working for us (in mutliple projects). Is there any known issue?

[AbhiPrasad]

Was there an announcement for that anywhere

No I think we messed up there 😅 - we'll send out some messaging for this!

[cthier-eb]

Thanks @AbhiPrasad - We'll also update the dependency. Thougj, just like @joshdales, would be great to get a more proactive communication if a breaking change like this happens 😃

[TonyCTurner]

Just for clarity, what minimum version # should be used to get back to working logs? thanks much

[TonyCTurner]

Ours stopped working last week

[AbhiPrasad]

9.17.0 for JavaScript: https://docs.sentry.io/platforms/javascript/logs/#requirements

2.28.0 for Python: https://docs.sentry.io/platforms/python/logs/#requirements

[KodeJaROM]

Will it be possible to query the logs in Sentry via an API?

[AbhiPrasad]

Hey @KodeJaROM what is the use case you want for querying logs via the API? We are evaluating this at the current moment.

[vixez]

Is there a concept of sessions with this feature?
So everything a user does in a session is grouped together.

Also, how long do these logs stay available?

[AbhiPrasad]

Hey @vixez.

Is there a concept of sessions with this feature?

We do group logs by trace, so you can see all logs associated to a certain pageload or request. If you use Sentry Session Replay, you'll be able to see all your logs associated to a certain replay, which basically is a user session.

Otherwise you can generate your own sessionId in the frontend and attach it to all logs as an attribute.

Also, how long do these logs stay available?

right now you can query for the past 14d, but we are planning to increase this after the beta. Still figuring out what the exact experience around this should be. What retention period for logs are you looking for?

[vixez]

Hey @AbhiPrasad ,

Okay thank you for the info.
We currently also store our logs for 14 days.

Kind regards

[Dhrumil-Sentry]

Sharing a bunch of product updates that shipped recently !

Support for PHP Logs: See the SDK instructions here

Infinite Scrolling: No more pagination, scroll your logs till the end and jump back to the top with a click:

Improved Timestamps: You can see log timestamps in your preferred timezones, UTC and more