In May 2026, OpenTelemetry (OTel) officially graduated from Cloud Native Computing Foundation (CNCF). This milestone marks the cloud native ecosystem’s achievement of production readiness and maturity, thanks to the efforts of hundreds of companies and thousands of developers who believed in an open standard for observability and built it together.

OpenTelemetry was already the standard. Now it’s official.

If you’ve been shipping production code over the last few years, OpenTelemetry has almost certainly touched your tech stack, whether through its SDKs and collectors, or traces, metrics, and logs. For many teams, OTel has quietly become part of the default toolbox for building and operating modern applications. It solves a real problem: the industry needed a common language for telemetry data, and OpenTelemetry became that language.

CNCF graduation reflects the strength of the ecosystem: a diverse contributor base, widespread vendor support with proven production readiness, comprehensive security audits and a governance model built by the community, for the community and for future sustainability.

Why a shared standard changes everything

Graduation formalizes OpenTelemetry as the common protocol and shared language for observability:

1. A standard protocol allows different tools, open source and commercial, to work together.
2. Semantic conventions define how telemetry is named and structured. When all systems speak the same language, correlation becomes possible at scale.
3. OpenTelemetry decouples instrumentation from backend analytics, enabling teams to export telemetry data to any backend system and switch analytics platforms without rewriting code.
4. Standardized, high-quality telemetry data allows automation, anomaly detection, and AI-driven insights. A consistent protocol becomes critical as systems grow more complex and autonomous.

Dynatrace loves OpenTelemetry and open source

Dynatrace has been involved in shaping OpenTelemetry from its early days, contributing to the specification, semantic conventions, Collector, and many other areas, ensuring the standard works at enterprise scale. With over 46,000 contributions and 54,000 commits, Dynatrace is one of the top contributors to the project.

Our focus has always been clear: make OpenTelemetry production-ready without compromising its open, vendor-neutral model.

Beyond OpenTelemetry, Dynatrace actively contributes to over 30 open source projects, including W3C Trace Context, and integrations with Kubernetes, JMeter, and more.

Frequently asked questions

Is OpenTelemetry stable after CNCF graduation?

Yes. Graduation confirms that the core specifications, APIs, and data model are stable and suitable for long-term production use. Teams can adopt OpenTelemetry with confidence across environments and use cases.

Does OpenTelemetry lock teams into a specific vendor or backend?

No. OpenTelemetry decouples instrumentation from backend analytics. Teams can export telemetry data to any backend and switch platforms without rewriting instrumentation code.

How does Dynatrace support OpenTelemetry?

Dynatrace supports you wherever you are. You can ingest pure OpenTelemetry data natively; no proprietary agents are required. From there, you can query billions of spans in seconds, correlate metrics, logs, and traces automatically across petabytes of data, and get the full observability context.

Want to see OpenTelemetry in action?

Learn more about OpenTelemetry at Dynatrace Hub.

The post OpenTelemetry graduates: A milestone for the observability Open Source community appeared first on Dynatrace news.

The real OpenTelemetry challenge: When OTel meets scale

Standardizing on OpenTelemetry gives teams flexibility and control in modern cloud native architectures. The instrumentation works. The data flows. The collection is solved. However, as organizations scale out OTel, they encounter the analytics gap- and the cost continues to climb without clear returns. Can your observability platform turn millions of spans and log lines into clear, contextual answers without manual correlation or vendor lock‑in?

While having OTel data is exciting, many teams find themselves asking, ‘What’s the actual payoff?’ Engineers may occasionally explore telemetry data, but without intelligent analytics to connect the dots, the data often remains underutilized. Meanwhile, managers struggle to quantify the value of their investment, especially as costs climb with scale. This is the natural challenge of DIY setups, where teams focus on data collection but rarely think critically about turning that data into actionable insights.

Anyone can analyze a single trace; that’s easy. Deriving answers from millions? That’s the hard part. The promise remains unfulfilled. Until now.

Why OpenTelemetry + Dynatrace changes everything for teams

Dynatrace closes this gap. With Dynatrace, all telemetry signals are combined to give you the insights you need:

• Comprehensive failure analysis across large trace sets
• Response-time insights revealing performance patterns at scale, with logs and exceptions in context
• Deep visibility into database and queuing systems
• AI-powered intelligence delivering contextualized insights
• Enterprise operational controls providing cost allocation, secure data handling, and scalable telemetry management

Your OpenTelemetry data transforms into actionable contextualized answers that help you move faster, ship confidently, and get back to building.

Complete enterprise coverage for OpenTelemetry

Dynatrace brings OpenTelemetry for Enterprise to life through specialized analysis designed for practitioners troubleshooting issues in Kubernetes environments, available in our extended Services app. AI-powered intelligence, including anomaly detection, ensures you get answers faster, without losing context.

Failure analysis: from single traces to mass insights

When your booking service fails, you can see the complete story: failed traces, related log entries, specific database statements, exceptions- all automatically correlated in one view. The Failure Analysis also provides a visual investigation of your OTel data.

Time-based comparisons allow you to overlay current failures against previous windows, instantly identifying regressions- what was stable yesterday and failing today becomes obvious. And there’s more: advanced visualization distinguishes between different failure types and severities, automatically categorizing them so you can prioritize based on actual user impact.

It’s a new, intuitive way to explore data visually with full context- analyzing failure patterns across your entire architecture and understanding how problems flow through distributed systems. Derive answers from millions of spans that individual trace inspection would never reveal.

Response time analysis with full telemetry context

Mass data analysis extends to performance insights. Dynatrace delivers response time analysis and comparisons built for practitioners. The platform allows you to easily compare failures between two time windows to spot exactly when things degraded.

See how response times correlate with database performance, downstream dependencies, like calls or queue interactions, and infrastructure resource utilization.
Dive in visually, explore the correlated context, and understand what’s happening- all in one place.

Database queries: understand service-to-database interactions

Modern services thrive or fail based on their interactions with their databases. Dynatrace provides comprehensive database analysis for OpenTelemetry-instrumented services, showing exactly what your services are doing against your databases.

Get immediate visibility into your most expensive queries across your entire environment- whether it’s Cassandra, SQL, or other databases. Queries are automatically ranked by cumulative duration (query count times query duration), surfacing what’s actually costing you performance.

When troubleshooting an individual service, you immediately see which database calls are problematic. You can also examine patterns across many services: identifying query problems, detecting spikes, or discovering when services start overwhelming databases with inefficient calls. The view aligns with how your architecture actually functions.

Cloud native queuing systems support

Modern applications stream data through Kafka, RabbitMQ, MQTT, and SQS, sending thousands of messages per second through distributed architectures. Dynatrace delivers comprehensive visibility into these message processing interactions with dedicated metrics, dashboarding, and alerting designed specifically for how modern streaming systems actually operate.

See which services are publishing or receiving messages from which queues, with full performance metrics. Advanced filtering lets you explore your entire environment or drill into a specific service’s queue interactions.

Exception analysis: uncover patterns and failures

We’ve only scratched the surface of how service analysis capabilities can make an impact. From the Services app, you can seamlessly navigate to related traces in the Distributed Tracing app, which now includes extended Exception Analysis. This enhancement surfaces exceptions across traces with readable stack traces, aggregated insights, and visual markers to highlight problematic spans.

By analyzing exceptions in context, teams can quickly identify patterns, prioritize fixes, and reduce MTTR. Whether leveraging OneAgent or OpenTelemetry, no critical issue goes unnoticed, providing complete visibility and reliability across modern environments.

AI-powered intelligence: pinpoint the needle in the haystack

Dynatrace AI delivers actionable insights through baselining, anomaly detection, and precise alerting, continuously learning your environment’s behavior. From day one, these capabilities surface meaningful deviations with full context, enabling teams to act quickly and confidently.

By analyzing OpenTelemetry data, you can detect trends, predict potential issues, and get intelligent, context-rich alerts. This ensures teams can focus on what matters most- resolving problems faster and optimizing performance- without manual effort or guesswork.

Enterprise operational controls that scale

Beyond analytics, enterprise teams need operational capabilities that work with OpenTelemetry data:

• Primary fields and tags: Use your existing Kubernetes labels and cloud tags (AWS, Azure) to filter and organize telemetry data. Filter by namespace, cluster, deployment, or custom business dimensions to focus on what matters most.
• Cost allocation: Track and understand costs by subscription, project, or resource group to optimize spending and ensure efficient resource usage.
• Pipeline routing and processing: Route telemetry data to specific pipelines based on cloud provider, region, or cluster. Control how data flows through your observability stack to improve efficiency and ensure compliance.
• Bucket assignment: Assign data storage by environment, account, or custom dimensions. Optimize retention and costs while adapting to operational requirements.
• Security context: Tag data with permissions and access controls, so teams see only the namespaces and services they’re authorized to access.

These aren’t add-ons; they’re core platform capabilities that work identically whether you use OpenTelemetry or OneAgent instrumentation.

The bottom line

Success comes from choosing the analytics platform designed for practitioners in modern environments- one that delivers insights across millions of signals with AI-powered intelligence. Dynatrace meets you where you are with the “Data in Context” advantage: every signal works together with the enterprise capabilities that cloud native environments demand.

The enhanced Services app and the Distributed Tracing app are now available for Dynatrace Platform Subscription (DPS) customers.

Check out the Dynatrace Playground to experience OpenTelemetry for Enterprise firsthand.

Join us at Perform in Las Vegas, January 26-29!

The post Data in context: How Dynatrace solves the OpenTelemetry analytics challenge appeared first on Dynatrace news.

OpenTelemetry excels at capturing data from any environment and service: traces flowing from microservices, metrics streaming from containers and infrastructure hosts, and logs capturing the application and service lifecycles. OTel does exactly what it was designed to do: standardize telemetry collection. But here’s what OpenTelemetry doesn’t do by design: unified observability that analyzes that data, correlates it across services, or turns it into actionable, intelligent insights.

This is where most organizations hit a wall and require lots of expert knowledge. Organizations today have more observability data than ever before, but somehow less visibility into what’s actually happening in their systems. Raw telemetry data becomes a burden rather than an asset. Engineers spend more time hunting through dashboards than solving actual problems.

This is the “analytics gap” that Dynatrace was built to solve, transforming your telemetry data from scattered signals into unified, AI-powered intelligence.

Why OpenTelemetry + Dynatrace changes everything

Here’s what makes this combination powerful: OpenTelemetry gives you standardized data collection. Dynatrace gives you intelligent analysis that goes far beyond the static dashboards and manual correlation work that other platforms require.

While many observability solutions leave it to you to build custom dashboards and manually connect the dots between your telemetry signals, Dynatrace transforms your OpenTelemetry data into insights that actually drive decisions. Your traces, metrics, and logs aren’t just stored; they’re automatically correlated, analyzed, and contextualized as they flow through Dynatrace OpenPipeline®.

When a trace shows latency spikes, you immediately see related log entries and metric anomalies automatically contextualized and correlated. Lightning-fast queries via Dynatrace Grail® data lakehouse process millions of spans at the speed of thought, making observability accessible to your entire team, not just the experts who know how to build complex queries and visualizations.

The result? Your OpenTelemetry investment becomes a competitive advantage, not just another data collection project that requires a team of dashboard architects to maintain.

Complete OpenTelemetry coverage

Here’s how Dynatrace helps you to get the most out of your telemetry data, without requiring additional agents or complex configurations:

Distributed tracing excellence

Native OpenTelemetry tracing delivers superior span and trace processing with dynamic visualization tools that transform complex distributed architectures into complete end-to-end visibility. But it doesn’t stop there; all your telemetry signals (logs, traces, and metrics) correlate seamlessly, giving you clear, actionable insights within the full context of your traces and services. Get simple answers to advanced questions by expanding your investigations with DQL for powerful analytics, including correlation of logs and traces.

Service monitoring that understands your Architecture

Comprehensive service health monitoring built on OpenTelemetry standards. Dynatrace provides intelligent service analysis, anomaly detection, and visualization that work seamlessly with your OpenTelemetry-instrumented applications. Our service monitoring goes beyond simple health checks.

When issues arise, you see exactly which services are affected and how problems cascade through your architecture, all without manual tagging, configuration, or service discovery setup with YAML files.

Intelligent metrics with full context

You get flexible metric ingestion for custom business metrics and standard application performance indicators. Your metrics connect directly to the services and traces that generated them. But here’s where Dynatrace takes it further: we allow you to unify all your OpenTelemetry signals into comprehensive service intelligence. Instead of analyzing metrics in isolation, you see how they connect to actual service behavior, request flows, and application logs. Every metric becomes part of a complete service story.

Complete log processing

Your OpenTelemetry logs are transformed from noise to narrative. Instead of searching through endless log streams and manually created dashboards, Dynatrace supports a comprehensive log ingestion and analysis pipeline, allowing you to go big with Dynatrace.

Every log event becomes part of a larger story about user journeys, interactions, services, and app behavior, all focused on your desired business outcomes and incident investigations.

Here’s where it gets powerful: you automatically get additional contextual enrichment when you direct all your telemetry signals to Dynatrace. By creating bi-directional relationships between logs and traces, where logs provide context to traces and traces illuminate relevant logs, Dynatrace evolves troubleshooting from detective power-user work into AI-driven, streamlined, and intuitive investigations.

Video: See the full story behind every trace with correlated logs.

Kubernetes native support

For teams running OpenTelemetry in Kubernetes, Dynatrace delivers enterprise-grade support that scales with your cloud native operations. Native Kubernetes handling of spans, metrics, and logs from your Kubernetes OpenTelemetry deployments automatically collects Kubernetes context for automated enrichment: namespace, cluster, and workload relationships, all without any additional instrumentation. Your existing Kubernetes labels, AWS tags, and Azure tags become first-class filtering dimensions for all OpenTelemetry data, enabling automatic cost attribution and comprehensive data permissions using your existing RBAC patterns.

The result is that your OpenTelemetry observability inherits the same operational patterns, security boundaries, and cost structures as your Kubernetes infrastructure.

Why this matters for your team

Every organization adopting OpenTelemetry faces the same challenge: turning data collection into intelligent insights. The engineering teams that succeed are those that choose analytics platforms built specifically for OpenTelemetry data.

Dynatrace transforms your OpenTelemetry investment from a data collection project into a competitive advantage. We meet you where you are. We respect your choice to standardize OpenTelemetry by simplifying its operational complexity and enhancing it with analytics that actually deliver value.

Ready to transform your OpenTelemetry data?

Open standards have clear benefits. Industry standardization makes it easier to make sense of data coming from multiple different sources, whether it’s traces, metrics, logs, or telemetry from third-party tools. Your analytics platform can deliver intelligent insights across your entire technology stack. Your OpenTelemetry investment deserves analytics that reveal its full potential.

• Want to explore specific OpenTelemetry capabilities with Dynatrace? Try them out on the Dynatrace Playground
• Boost your productivity with these quick video guides for service owners working with OpenTelemetry:

Video: Easy access to your OTel Logs and Traces

Video: Analyze Service Failure from OTel Data

Video: Easy access to your OTel & Prometheus Service Metrics

Join us at OpenSource Summit. We’ll be in Amsterdam August 25-27. Stop by our booth to see the magic in action!

The post OpenTelemetry and Dynatrace: Complete unified observability analytics for modern applications appeared first on Dynatrace news.

It’s 3:00 AM. Alerts are firing. Something’s broken, latency is spiking, there’s too much noise, and you’re under pressure to find the root cause fast. You need to be able to understand how your system interacts to solve the problem as soon as possible. But systems just keep getting more complex as your organization adds new technologies, AI models, and container-based microservices. That’s why, as complexity scales, so does the need for connected insights. In the world of observability, logs and traces serve distinct but complementary purposes. When used together, they unlock a powerful view into system health, performance, and behavior.

The secret lives of logs and traces

In theory, correlating logs and traces should be straightforward. However, in practice, teams often find themselves context-switching to follow the path of a trace and all the logs involved. To understand why, let’s take a closer look at the roles and responsibilities of logs and traces.

Traces: The big picture view

Traces follow the journey of a request as it moves through various services in a distributed system. They provide end-to-end observability of how different components interact, making them ideal for understanding latency, bottlenecks, and service dependencies. Distributed traces connect events into a cohesive timeline, helping engineers see how one service’s performance affects others.

Traces shine when you’re trying to answer questions like, “Where did this request slow down?” or “Which service caused the failure?”

Logs: The detailed detective work

Logs are detailed, timestamped records of events generated by applications and infrastructure. They’re rich in context, often containing error messages, debug information, and custom outputs that developers write into the code. While traces show the flow, logs show the details. Logs can exist independently of traces and are often the first place developers look when something goes wrong.

Logs shine when you’re trying to answer: “What exactly happened here?”

Don’t forget metrics and other telemetry signals

Although we’re focusing here on logs and traces, metrics and other telemetry data are also essential for observability and deeper context. For more about why it’s important to unify the full spectrum of observability signals, see What is observability and Unified observability: Why storing OpenTelemetry signals in one place matters.

The power of correlating logs and traces from a single, full-context platform

Isolated telemetry signals can lead to blind spots and wasted time searching for answers. Some of the main ways to use logs and traces are to simplify troubleshooting, enhance performance, improve security posture, and meet compliance standards.

When you can correlate logs and traces from a single source of observability data, you eliminate the constant context switching that slows down investigations. Instead of toggling between tracing tools and log viewers, you get a unified view that connects the dots fast.

Correlating logs and traces from a single platform transforms troubleshooting from a fragmented hunt into streamlined analysis, where you spend time solving problems instead of searching for information. Core technologies like Grail®, OneAgent®, and Davis® AI provide the scalable foundation while embracing open-source frameworks like OpenTelemetry for flexibility.

Cracking the case of the failed checkout: Investigating logs and traces

Not every investigation starts the same way. Sometimes a trace gives you the high-level view you need to spot an issue and dive deeper. Other times, a log entry is the first clue that something is off. In the next section, we’ll walk through two examples, one that starts with traces and the other with logs, to show how you can get the answers you need.

Scenario 1: Investigating from traces to logs

While doing some routine monitoring in the Distributed Tracing app, we notice a series of failed requests in our Kubernetes prod namespace. So we filter for unsuccessful transactions to examine them more closely.

One request stands out: “/cart/checkout”. It’s a critical transaction path, and we’re seeing failures.

We dive into the trace waterfall. Just below it, we find the logs tied to each span, giving us deeper insight. That’s where we find the message:

“error: failure to complete the order”

Digging further, another log reveals the root cause: only Visa and Mastercard are accepted, which is in line with our policy, but potentially limiting our business. This raises a new question: how often is this happening?

With a single click, we pivot to the logs app, where we can search for this specific message and quantify how many transactions may have been impacted.

This approach turns scattered signals into a cohesive story, helping us move from surface-level symptoms to actionable insights with speed and precision.

Scenario 2: Investigating from logs to traces

No matter how you start your day, whether you are coming from PagerDuty, Slack or start directly in Dynatrace through one of the many apps like Kubernetes or the Clouds app, you can always see logs in context of your investigation.

In this scenario, we’re investigating this case from another angle, starting with the logs app using the prefiltered segment for the Kubernetes prod namespace. The view is tailored to the services we own. A quick scan reveals something suspicious: numerous errors in some of the log files.

To dig deeper, we navigate in the logs app and use the content filter for “payment” and “error”, and we find several logs with the following message:

Could not charge card for user id = xxxxxxxxxxxxx

But what is causing the failure? We click Show surrounding logs, which reveals all logs associated with the trace ID. Now we can view log messages sequentially as they happened.

Investigating some of the surrounding logs, we see that the user is using a credit card other than Visa or Mastercard, which our organization doesn’t support. Now that we understand why things are failing, let’s investigate further to see if we can optimize this experience.

To understand the full impact, we pivot seamlessly to the trace view. Here, we see the full waterfall breakdown of the request: service calls, timing, and span-level metadata.

One detail stands out: it took 5 seconds for the user to receive the failure message. That’s a long time to wait just to be told their card isn’t supported.

With this insight, we can now make targeted improvements so that the user does not have to wait a long time to understand that their payment method is not supported and deliver a better user experience.

While these examples highlight how seamless navigation between logs and traces accelerates troubleshooting, they’re just one part of the story. With Dynatrace Grail and Notebooks, you can take things a step further by running advanced queries, automating repetitive tasks, and building collaborative, data-rich workflows. These tools empower teams to go beyond reactive troubleshooting and into proactive, scalable observability.

Why seamless navigation between logs and traces matters

Seamless navigation between logs and traces isn’t just a convenience; it’s a game-changer. Whether you start with a trace or a log, the ability to pivot instantly between signals means you spend less time hunting for answers and more time solving problems. It accelerates root cause analysis, improves team collaboration, and gives you the full context needed to act with confidence. This is just one example of how Dynatrace helps you move from fragmented troubleshooting to unified intelligent observability.

Ready to start investigating?

Explore Distributed Tracing and Log Management and Analytics, complete with prepopulated data in the Dynatrace Playground.

The post Logs and traces: Why context is everything for seamless investigations appeared first on Dynatrace news.

Get ready to experience a whole new world of limitless tracing power. With our latest enhancements, we’re transforming the way you work with trace data. The Dynatrace® platform now enables comprehensive data exploration and interactive analytics across data sets (trace, logs, events, and metrics)—empowering you to solve complex use cases, handle any observability scenario, and gain unprecedented visibility into your systems. Whether you’re using OpenTelemetry or OneAgent, operating in the cloud or on-premises—we’ve got you covered.

Introducing a new era of distributed tracing with advanced analytics

In today’s complex systems landscape, understanding the root causes of issues can be daunting, especially as applications scale and OpenTelemetry adds complexity.

Davis® AI automatically pinpoints root causes, offering immediate answers. For deeper exploration, our Distributed Tracing app empowers you to analyze raw trace data and uncover insights, whether troubleshooting errors, optimizing performance, or discovering the “unknown unknowns.”

But why stop there? Building on this solid foundation, we’re thrilled to announce two powerful platform enhancements. Say hello to advanced trace analytics and new data storage and capture options. These game-changing features elevate your data interactions, opening up vast possibilities for advanced queries and efficient data management tailored to your needs.

Site reliability engineers, performance architects, and developers can now leverage dynamic analysis tools like dashboards and workflows to explore trends, automate processes, and maintain control at an unprecedented level. Additionally, these queries serve as excellent starting points for more complex data explorations with Notebooks.

Get ready to maximize the full potential of your trace data—unlock deeper insights and automate like never before, all within a single platform.

Level up your analytics game: Enhanced team collaboration and advanced data insights

With traces now stored in Dynatrace Grail™, our scalable data lakehouse, you can unlock powerful new analytics capabilities, handle massive volumes of data, and run complex queries seamlessly. Combining traces with logs, metrics, Kubernetes events, and telemetry attributes gives you a complete, contextual view of your environment for unmatched end-to-end observability.

Unlock deeper insights

Using Dynatrace Query Language (DQL), you can extract game-changing insights from raw span data with precision. Use these queries to start more complex data exploration with Notebooks. This enables you to uncover hidden patterns, discover unknown unknowns, and make confident, data-driven decisions. These powerful insights can easily be transformed into interactive dashboards.

Example: Exception analysis

Understanding patterns, especially regarding exceptions, is no easy feat. However, you can begin unlocking additional insights using the Distributed Tracing app. For example, you can filter to understand endpoint performance where exception messages contain the string, access denied.

Once filtered, you can easily open a notebook with a pre-populated DQL query. You can then add additional details or modify the query as needed. Combine multiple findings in a notebook or dashboard to share your analysis with your team, allowing them to see these focused updates live in real time.

Achieve superior analytics

Transform trace data into intelligent insights by combining trace data with logs, metrics, and events. This combination allows you to enrich all data and get details in context. Use this intelligent data to see what matters to you most in real time by creating interactive dashboards and driving better decision-making. This gives you the power to break down silos, spark collaboration, and extract actionable insights with ease. It democratizes access to critical data, ensuring all teams can leverage the same reliable insights to drive impactful outcomes.

Example: Combine trace data with logs

A common scenario is understanding which frontend API requests have log messages on the backend indicative of a specific problem. Let’s look at an example where the log message contains timeout, and we want to understand the response time of traces in the context of these messages.

By linking trace data with logs, you can query across spans and related log messages. You can also summarize with DQL to understand how often a specific pattern occurs. To visualize span duration, use p99 to see the slowest percentile of span response times and then navigate directly to the traces.

Automate with Dynatrace OpenPipeline

With Dynatrace, you can create custom metrics from trace data using Dynatrace OpenPipeline™, unlocking powerful new automation capabilities. It’s now possible to create metrics on OpenTelemetry and OneAgent spans with any available attribute, giving you the power to define operational, request, and method-level metrics.

OpenPipeline provides the flexibility to build metrics tailored to your specific needs, enabling you to integrate metrics seamlessly with advanced Dynatrace automation features, such as AutomationEngine and SRE Guardian. You can streamline workflows, intelligently automate repetitive tasks, proactively resolve issues, and spend more time innovating with automation, ensuring that only reliable, high-performing code reaches production.

We’ve only scratched the surface of scenarios where advanced analytics can make an impact—the possibilities are virtually endless. By combining advanced trace analysis, intuitive query capabilities, and seamless automation, your team can enable sharper analysis, streamline workflows, and foster innovation. This powerful approach ensures you can focus on delivering better outcomes with greater efficiency, empowering your organization to tackle complex issues with precision and agility, ultimately bringing unprecedented value.

Extended trace retention: Retain data longer when it matters

Need to analyze trends over the long term or adhere to compliance requirements? With extended trace retention, you can store trace data for up to 10 years. This feature ensures your organization is well-equipped for trend analysis and detailed post-mortem reviews—all while meeting regulatory requirements.

Retention policies are fully configurable in OpenPipeline. You can share data in buckets with varying retention times depending on the use case, allowing you to target specific applications or error-prone services for longer storage. This precision reduces storage costs while ensuring you retain the data that matters most.

Extended trace ingest

You can now customize trace ingestion rates to meet your specific needs. While most trace data is already ingested at high coverage rates, this option gives you more granular control over your trace volume. Ingest as much data as you want, above and beyond what is already included in your Dynatrace license.

Maximize the value of your OpenTelemetry data

At Dynatrace, we love OpenTelemetry. We champion open source innovation and recognize OpenTelemetry’s influence in setting observability standards (we’re also a top contributor). That’s why our advanced capabilities were designed from the ground up with OpenTelemetry at its core. We built our entire new tracing experience on OpenTelemetry semantic conventions and expanded from there. Now, OpenTelemetry users can troubleshoot and analyze while leveraging  OTel standards. This commitment empowers you to simplify complexity and innovate faster by extracting maximum value from your data, regardless of origin.

Experience the future of Distributed Tracing

At Dynatrace, we believe that observability should be effortless and completely on your terms. With our latest advancements, we’re helping you manage complexity, innovate faster, and push boundaries. Our solution adapts seamlessly to your ecosystem, whether you use OpenTelemetry or run cloud-native or on-premises workloads. Built to handle enterprise scale, the Dynatrace platform processes massive volumes of data in real time while unifying insights across all teams in your organization.

We’re rolling out this functionality to existing Dynatrace Platform Subscription (DPS) customers. Elevate your observability journey with these new possibilities—tailored to your needs, your way.

If you’re not a DPS customer, you can try out the new Distributed Tracing experience with prepopulated data on the Dynatrace Playground.

If you’re new to Dynatrace and want to try out the new Distributed Tracing experience with your own data, check out our free trial

Take the leap today and discover how Dynatrace can revolutionize your approach to observability.

The post Distributed tracing with Dynatrace just got even better appeared first on Dynatrace news.

Companies face mounting pressure to digitally transform and deliver seamless cross-channel experiences. These experiences are critical not only for attracting new prospects and driving satisfaction but also for providing more value to customers and enabling business growth. Adobe Experience Manager empowers businesses to optimize and deliver engaging experiences across websites, mobile apps, and other touchpoints. As part of delivering a compelling experience, it is vital that companies develop a deeper understanding of their customers. As a result, user experiences can be optimized, and issues can be proactively addressed before customers become frustrated with errors or broken journeys.

End-to-end observability across every tier powering your digital experiences using RUM

Application owners and SREs often struggle to get a complete picture of the customer journey and are unable to pinpoint issues due to a lack of comprehensive visibility. As a result, it is difficult to ensure application efficiency and ensure accurate delivery across touchpoints. This lack of end-to-end visibility leads to blind spots that impact customer satisfaction.

The Dynatrace platform offers comprehensive observability and monitoring across the entire technology stack. By going beyond application performance monitoring with AI-powered, full stack observability, Dynatrace enables seamless end-to-end visibility. Furthermore, by integrating with Adobe Experience Manager, you get quick visibility, ensuring application efficiency across all channels and the ability to scale in support of even the largest Adobe Experience Manager instances.

Dynatrace automatically detects all Adobe Experience Manager applications and visualizes their dependencies—from the website, to the container, to the cloud service. This enables you to enrich your Adobe analytics data with end-to-end traces across all tiers and to get precise, real-time user insights. You can monitor Adobe Experience Manager instances intelligently and provide personalized, content-driven experiences without gaps or blind spots.

By relying on Dynatrace® Digital Experience Monitoring (DEM) integrated with Adobe Experience Manager—specifically Real User Monitoring, Synthetic Monitoring, and Session Replay—you gain real-time insight into the user experience of their sites and applications. This capability extends across devices and geographies and includes critical front-end monitoring use cases like performance and availability monitoring, troubleshooting, root cause analysis, complaint resolution, and understanding user behavior. This allows teams to understand exactly where to make improvements in the Adobe Experience Manager stack and deliver a smoother, more personalized experience to customers.

Furthermore, Dynatrace turns analytics into real-time answers, enabling you to better understand how applications’ outages impact critical business metrics like conversions, revenue, and engagement. This actionable insight allows you to accelerate time to value, optimize customer experience, and meet your business needs.

Deliver excellent customer experience with the powerful Davis AI engine

The Dynatrace Davis® AI engine allows you to diagnose anomalies when they arise in real-time and pinpoint the root cause down to the broken code before your customers are affected. You can now proactively detect availability and performance issues across the stack.

By enabling faster identification of potential issues, you can reduce mean time to repair and minimize customer impact. With AI-powered observability, you can quickly troubleshoot complex environments like Adobe Experience Manager to maximize uptime and customer satisfaction. The result is a smooth, uninterrupted user experience.

Visit Adobe Experience Manager documentation to learn more about the Dynatrace integration

Want to it out for yourself? Sign up for your Dynatrace free trial.

The post Dynatrace and Adobe Experience Manager: Seamless end-to-end observability appeared first on Dynatrace news.