With the wave of cloud-native transformation that’s been sweeping across the software industry in the past few years, Kubernetes has emerged as the backbone of modern application deployment and management.

However, as systems have evolved, traditional approaches to monitoring have struggled to keep up. To fill this gap, technologists have designed new tools and practices especially for modern, cloud-native environments. However, all this tooling and new workflows come with their own unique challenges.

Organizations now find themselves not only navigating the inherent complexities that come with the distributed nature of Kubernetes, but they’re doing it with a lack of unified data across their entire stack, especially when working in multi-cloud environments. Limited visibility into applications, a lack of full context, and data silos from multiple tools hinder their ability to get a comprehensive view of their systems and applications.

This is where the need for a unified platform becomes crucial, one that provides engineers with a full end-to-end view of their containerized applications, ensuring optimal performance, reliability, and proactive issue detection and resolution. Advanced monitoring capabilities, such as Dynatrace Kubernetes monitoring, are critical in achieving this performance.

The one-stop-shop for all Kubernetes observability needs

Dynatrace provides unparalleled end-to-end visibility across your entire Kubernetes stack. Gone are the days of gaps in visibility, lack of contextualized data, data silos, long resolution times, and inadequate context and alerts.

With Dynatrace Kubernetes monitoring, engineers gain unified observability across all their environments, the ability to drill down to pinpoint an issue, AI-driven insights, real-time data, and more.

We haven’t even discussed the best part yet, though. All of this is done end-to-end by utilizing the full power of the entire Dynatrace platform.

Dynatrace Kubernetes monitoring: End-to-end observability of your Kubernetes stack

End-to-end monitoring means having full visibility into every aspect of applications, from code and services to performance metrics. This awareness allows teams to quickly identify and resolve application issues, optimize performance, automate processes, and ensure a smooth user experience.

Dynatrace provides these capabilities in multiple ways.

Platform visibility

The Kubernetes application easily provides a comprehensive view of your entire Kubernetes inventory and the ability to drill down into individual clusters to eliminate blind spots. In a single view, engineers can easily see out-of-the-box health signals and resource indicators (including alerts), and easily explain warning signals, so they have real-time insights into the entire Kubernetes estate for easy and quick issue resolution.

Integrated observability

Dynatrace unifies telemetry data from all sources, including third-party data, providing a consolidated view of traces, metrics, and logs on a single platform. This integrated approach extends and adds value to the OpenTelemetry framework. With integrated observability, users gain deeper insights into application behavior and readily identify performance bottlenecks. Teams can monitor the golden signals—latency, traffic, errors, and saturation—to better understand the health and performance of applications in real-time. This allows teams to quickly pinpoint issues, leverage predictive AI-powered analysis, and ultimately ensure applications are running smoothly and efficiently across their entire Kubernetes stack.

AI-powered insights

The engine behind Dynatrace Kubernetes monitoring is Davis® AI, which is built into the Dynatrace platform. Davis redefines ‘modern monitoring’ by taking the guesswork out of troubleshooting. It detects anomalies and potential issues in real-time, providing proactive alerts before they become critical. Davis AI goes beyond alerting by performing data deep dives to pinpoint the exact cause of issues. This comprehensive analysis bubbles up the most important warning signals teams need to be aware of and provides clear, actionable insights to help users understand and resolve issues efficiently.

With the integration of Davis CoPilot™, teams can go a step further and navigate complex Kubernetes environments with confidence. CoPilot acts as a contextual guide to help teams of all levels understand Kubernetes-native concepts by explaining them in plain language and offering deeper insights into root cause and remediation options.

Log Management

Logs are critical sources of insight into Kubernetes environments. With Dynatrace, logs are centralized, easily accessible, and connected with other signals from your Kubernetes environments to allow speedy troubleshooting and effective monitoring. For instance, you can inspect and understand logs from crashing application containers and other workloads using the Dynatrace Kubernetes app. With Notebooks and DQL, you can analyze log data alongside traces and Kubernetes topology. For security issues and data forensics, Dynatrace supports evidence-based investigations. Metrics and events can be derived from logs for dashboarding and prediction, automating remediations with log data in the Workflows app, and manually exploring surrounding logs and patterns using Dynatrace Logs.

Observability for Developers

The widespread adoption of Kubernetes has made it easier and faster for organizations to deploy and manage software. However, this also means that developers are now facing more difficulties troubleshooting and understanding their code’s behavior. Dynatrace provides developers with real-time data and capabilities to overcome the highly distributed nature of Kubernetes workloads.

In addition to cloud-native apps such as distributed tracing, error analysis, and log analytics, the Live Debugger provides developers with real-time snapshots from their running code without the need to reproduce, add code, or redeploy. This helps them optimize their code and debug issues faster.

Additionally, application profiling with CPU, memory, and thread profilers help developers pinpoint processes and containers that consume CPU, identify memory leaks or usage patterns in order to solve issues and optimize their performance.

Users can also quickly understand why service requests are failing and identify root causes of increased failure rates with error and failure analysis.

Customization, automation, and ease-of-use

Managing Kubernetes workloads and clusters traditionally requires a lot of manual work that is often repetitive and time-consuming. Doing so at scale requires efficient resource management and automation to handle dynamic demands. Dynatrace’s automated workflows simplify this by predicting resource needs and scaling workloads accordingly. This allows you to manage your environments without constant oversight.

Workflow automation in Dynatrace allows for custom scaling events, based on Davis AI forecasting, enabling automated, predictive resource scaling for Kubernetes. This lets you manage your environments without the need for constant oversight, ensuring proactive issue detection and resolution.

Support for GitOps with automated observability, automatic anomaly remediation, and performance optimization are just a few ways this can be achieved.

With Dynatrace automation capabilities, monitoring your Kubernetes clusters becomes a seamless experience.

Dynatrace Kubernetes monitoring for seamless automation

In the dynamic world of cloud-native and Kubernetes, having integrated observability, AI-driven analysis, and automation is crucial for success—and Dynatrace is the answer. Let Dynatrace manage the dynamic intricacies of Kubernetes so your teams have the intelligence they need to automate and optimize.

Utilize the full power of the Dynatrace platform to gain unparalleled observability of your entire Kubernetes stack, ensure optimal performance and reliability, and proactively detect issues and automate resolution.

The post How Dynatrace Kubernetes Monitoring powers smarter insights appeared first on Dynatrace news.

In April, KubeCon + CloudNativeCon kicked off its 2025 world tour in London. With more than 13,000 attendees, KubeCon EU reaffirmed its reputation as the go-to forum for cloud-native developers and platform engineers. This year’s milestone included the celebration of the CNCF’s 10th birthday and the 11th anniversary of Kubernetes, underscoring the profound impact of these technologies on the global tech landscape.

From insights into observability and platform engineering to groundbreaking advancements in security and AI/LLM integrations, the conference offered a wealth of knowledge. For Dynatrace, it was an exciting opportunity to showcase our innovations, collaborate with the open source community, and contribute to discussions shaping the future of cloud-native computing.

Here’s a breakdown of the biggest highlights, emerging trends, and key Dynatrace sessions from KubeCon EU 2025.

Highlights from KubeCon EU 2025

For observability watchers and cloud-native fans, KubeCon EU didn’t disappoint.

1. The unstoppable growth of cloud native

With 9.2 million cloud-native developers worldwide and events expanding from India to Japan and North America, cloud-native technology is scaling faster than ever. The CNCF annual report reveals how essential cloud-native applications have become to industries everywhere.

2. Observability takes center stage

Observability dominated the keynote conversations this year. It’s no longer a “nice-to-have”—it’s a must-have for cloud-native environments. The industry recognizes the need for more basic education around observability, as it becomes crucial for identifying, monitoring, and resolving issues.

3. Kubernetes meets AI and large language models (LLMs)

Kubernetes has solidified its role as the platform of choice for deploying AI models and LLMs. These models demand efficient resource utilization and continuous monitoring to deliver accurate results.

To learn more about how to observe AI and LLMs using Dynatrace, check out our recent Observability Lab, AI and LLM Observability.

4. Platform engineering simplifies Kubernetes complexity

A key trend this year was the rise of Platform Engineering as the ultimate solution to tame Kubernetes complexity. By abstracting away the complex parts of managing K8s, platform engineering enables quicker and more reliable adoption throughout the organization .

5. Security and compliance for cloud-native apps

The EU’s Cyber Resiliency Act brought renewed attention to the importance of security and compliance. Across sessions and keynotes, there was a consensus that these concerns are now everyone’s responsibility, not just security teams.

6. Making observability explainable

One of the most inspiring takeaways came from eBay’s keynote on simplifying observability. They showcased how leveraging LLMs can make complex observability data more understandable, a philosophy that resonates deeply with how Dynatrace’s Davis CoPilot™ simplifies explanations for our users.

Event livestreams

Dynatrace organized two live streams, both pre-and post-KubeCon with cloud native experts to get all the insights about the conference.

Henrik Rexed, Principal Product Manager at Dynatrace, hosted three renowned cloud-native thought leaders on his Is It Observable? Channel, discussing KubeCon EU London and sharing the latest updates. Watch and listen to what Lin Sun, Abdel Sghiouar, and Mauricio Salatino had to say here on YouTube: Observable Live Coding: KubeCon Kickoff.

Make sure to catch the livestream recording of our Dynatrace open source experts Adriana Villela, Alexandra Oberaigner, and Henrik Rexed sharing their insights and takeaways in the Ask Me Anything session on the Dynatrace YouTube channel.

Dynatrace at KubeCon EU 2025

Dynatrace plays a great part in the exciting developments of cloud native. At KubeCon London, 11 Dynatrace innovators presented sessions and posters covering cloud-native technologies and how Dynatrace is helping to shape the future. Here’s an overview of our contributions to the event.

OpenTelemetry

Putting the Experience in UX: The Importance of Making Data Accessible

Adriana Villela (Dynatrace) and Marino Wijay (Kong Inc.) discuss the importance of making data accessible to all organizational roles, not just IT-focused teams. Using real-life examples, they highlight how a positive experience with data can spark curiosity, unlock new insights, and drive innovation across departments like sales, marketing, finance, and HR.

Customize Your Own OpenTelemetry Collector

Evan Bradley (Dynatrace) and Pablo Baeyens (DataDog) show you how to customize your own OpenTelemetry Collector with the OpenTelemetry Collector Builder (OCB). This tool, developed by the Collector maintainers, lets you include the exact components you need or create your own for unique use cases. The session explores OCB basics, building release pipelines, publishing Docker images, applying hotfixes, and using custom components—plus real-world examples of OCB in action.

How Green Is My OpenTelemetry Collector?

Adriana Villela and Nancy Chauan explore the environmental impact of telemetry and how it contributes to the tech carbon footprint. They introduce the Kepler project, which tracks power consumption metrics in Kubernetes clusters. The session covers what Kepler is, how to deploy it, and a demo on optimizing OpenTelemetry Collector power usage, offering actionable insights for reducing energy consumption and costs.

Smooth Scaling with the OpAMP Supervisor

Evan Bradley (Dynatrace) and Andy Keller (observIQ) show how the OpAMP protocol simplifies managing OpenTelemetry Collectors with seamless remote configuration and control. This session, led by experts from Dynatrace and observIQ, will cover integrating OpAMP into Collector distributions using the new OpAMP Extension and Supervisor. Gain insights into its architecture, features, and see a live demo showcasing centralized configuration, monitoring, and updates.

OTel Sucks (But Also Rocks!)

This talk by Juraci Paixão Kröhling (OllyGarden) and Daniel Dyla (Dynatrace) dives into OpenTelemetry’s challenges and successes, covering SDK configuration improvements, collector performance issues, and evolving semantic conventions. With real-world insights, it offers an honest yet hopeful look at OTel’s growth—perfect for anyone navigating its complexities or appreciating its strengths.

OTel Me How To Get My Open Source Community Taken Seriously

Learn how to build and grow an open source community with Reese Lee (New Relic) and Adriana Villela (Dynatrace). In this session, they’ll share insights from their work with the OpenTelemetry (OTel) community, including strategies for collaboration, driving contributions, and demonstrating business value. Attendees will also hear about key lessons and practical tips to strengthen their own open source projects.

OpenFeature

OpenFeature’s Positive Impact on Confidence at Dynatrace

Simon Schrottner and Todd Baert (Dynatrace) dive into how Dynatrace adopted OpenFeature to address challenges with their fragmented feature flag system, such as unclear use cases and legacy flags. By integrating OpenFeature with OpenTelemetry, they improved feature flag observability, providing Site Reliability Engineers with actionable insights to assess potential impacts confidently. This shift is enhancing their workflows and benefiting the broader developer community.

OpenFeature Updates from the Maintainers

Learn about the latest updates in OpenFeature as presented by Thomas Poignant (Adevinta), Lukas Reining (codecentric AG) and Alexandra Oberaigner (Dynatrace). This session covers new developments like code generation, event tracking, OTEL semantic conventions, distributed flag evaluation, and future plans. Join the discussion and get your questions answered!

Type-safe Feature Flagging in OpenFeature

Learn how to improve feature flagging with OpenFeature, a vendor-agnostic API, in this talk by Michael Beemer (Dynatrace) and Florin-Mihai Anghel (Google). They address common challenges like typos and stale flags in traditional SDKs and demonstrate how the OpenFeature CLI creates type-safe accessors to enhance reliability and the developer experience.

Platform engineering

DORA Metrics in Practice

Learn how to leverage DORA metrics like deployment frequency, lead time for changes, mean time to recovery, and change failure rate to enhance engineering performance. This talk by Danielle Cook, CNCF Ambassador, and Andreas Grabner (Dynatrace) shares insights from Dynatrace’s Internal Development Platform, Juno, covering observability best practices, standard interfaces, and actionable strategies to measure and improve your Software Delivery Lifecycle. Perfect for those curious about or already using DORA metrics!

Cloud-native security

Catch More Hackers with Koney

This poster session by Mario Kahlhofer (Dynatrace) and Matteo Golinelli (PhD Student) showed how Koney, a Kubernetes operator, enhances cloud-native app security with honeytokens and deception policies. It automates trap setup, rotation, and teardown, using eBPF to detect and alert on unauthorized access.

To observability and beyond

KubeCon EU 2025 demonstrated that technologies like AI, LLMs, and Kubernetes are reshaping how we think about observability, security, and operational efficiency. At Dynatrace, we’re thrilled to be a part of this transformation, offering AI-powered observability and security that enables teams to innovate faster while staying secure and compliant.

For more great Dynatrace highlights from KubeCon EU 2025, see KubeCon EU 2025 retrospective: Reflections from my sixth KubeCon.

Watch for us at future KubeCon + CloudNativeCon events across the globe in 2025 and beyond!

The post KubeCon EU 2025 key takeaways: Spotlight on cloud-native observability appeared first on Dynatrace news.

I have just returned from what I can only describe as a whirlwind week that was the first KubeCon of 2025, KubeCon EU, which took place in London, England from March 31 to April 4. KubeCon is a massive conference, full of energy, great talks, and great friends, and my fellow Dynatracers and I couldn’t wait to get started. I gave three talks in three days, recorded interviews for the fourth edition of Humans of OTel, and recorded the second edition of the Humans of OTel Livestream. The following is a recap of my personal highlights from the conference and surrounding events.

Dynatrace speakers

We had a great lineup of Dynatrace speakers at KubeCon EU this year, with a total of 13 talks happening every day of the week. We kicked off the week on Monday with Henrik Rexed at Cloud Native Rejekts, and ended with Michael Beemer and Evan Bradley on Friday. You can see the full schedule of Dynatracer talks below!

Pre-KubeCon events

My teammate, Henrik Rexed, kicked things off on Friday, March 29th, with a pre-KubeCon livestream edition of Is It Observable, featuring CNCF Ambassadors and absolute cloud native heavyweights, Lin Sun (Solo.io), Abdel Sghiouar (Google), and Mauricio “Salaboy” Salatino (Diagrid).

Cloud Native Rejekts

Cloud Native Rejeckts is a two-day conference that takes place on Sunday and Monday before the main KubeCon event. This was my second time attending, but my first time not as a speaker. The Rejekts motto is: “Recycle your KubeCon talk here” …which means that if they’d rejected your KubeCon talk, you can submit it to Rejekts! Acceptance, of course, is not guaranteed, but it’s always worth a try!

Rejekts has a much more relaxed atmosphere compared to the frenzy that is KubeCon. It’s also quite a bit smaller, and much cozier. As a result, it’s a great way to catch up with folks who you would normally see at KubeCon, but who would most likely be too busy running around to stop by for a chat. Plus, it’s free to attend!

Henrik Rexed gave TWO talks at Rejekts, and I was able to catch the first one.

• In his first talk, The Service Mesh Wars: A New Hope for Kubernetes, Henrik compares and benchmarks five service mesh technologies (Istio, Linkerd, Cillium eBPF, Kuma, and Ambassador Edge) across multiple dimensions to demonstrate when and how to use them.
• Henrik’s second talk was called The Kubernetes Guardians: A Deep Dive Into Your Security Avengers. In this talk, Henrik and co-speaker Ben Hirschberg compare and benchmark four CNCF eBPF-based Kubernetes security tools (Falco, Tetragon, KubeArmor, and Kubescape) to help attendees decide which one best suits their needs.

Henrik is an excellent speaker, and his slides are always fun and engaging. I recommend catching one of his talks if you can.

PS: The conference venue was GORGEOUS!!

KubeTrain party

After the last day of Rejekts, I headed over to the KubeTrain arrival party, hosted by Dynatrace and Isovalent on March 31st. It was a ton of fun, and the best part was reuniting with my DevRel teammates Andi Grabner (aka “Mr. Dynatrace”) and Henrik. A few other folks also arrived in town that day whom I hadn’t seen at Rejekts, so it was nice to catch up. Also, the party featured a signature cocktail called the “Dyna-Tai”, and a signature mocktail called “Dynatrace Violet Crush”.

KubeCon

Official KubeCon events started on Tuesday, April 1st.

Co-located events

Although the main KubeCon conference started on Wednesday, April 2nd, on Tuesday, April 1st, the conference venue hosted a number of co-located events, including Observability Day, Platform Engineering Day, OpenFeature Summit, OpenTofu Day, ArgoCon, BackstageCon, and others. Like Rejekts, co-located events are always a great way to catch up with friends before the madness of KubeCon sets in.

I was fortunate enough to speak at my fourth Observability Day, this time with a fellow Torontonian, Marino Wijay of Kong, one of Dynatrace’s partner companies. Our talk was called “Putting the Experience in UX: The Importance of Making Data Accessible.” This talk was about using OpenTelemetry (OTel) outside of the traditional confines of technology. We already gather telemetry every day, in various aspects of life. OpenTelemetry provides us with a standard for generating, collecting, and emitting telemetry, and we have existing tooling that leverages OTel data to help us understand work processes and workflows. So why not extend these existing data ppints to edge use cases, such as employee onboarding, emergency room visits, and hiring?

I had originally crafted the talk proposal with one of my good friends, Tim Banks, who was unfortunately unable to travel to KubeCon. As a result, Marino took his place, and he and I crafted the talk together. I hope we made Tim proud!

Fun fact: Marino was my co-speaker at Platform Engineering Day in Salt Lake City last fall.

Ambassador Breakfast and KubeCon kickoff

As a CNCF Ambassador, KubeCon always kicks off with the Ambassador Breakfast at 07:30, during which we get to hang out with fellow Ambassadors, eat breakfast, and take a group photo before walking over to the opening keynotes together.

Fun fact: Dynatrace DevRel team members Andi Grabner, Henrik Rexed, Adam Gardner, and I are all CNCF Ambassadors!

The production level of the keynotes always blows my mind. Having been on the main stage at the Dynatrace Perform conference in February 2025, I had a taste of just how much time and effort goes into putting on a well-executed production. Mad respect to the folks behind the scenes who make all the magic happen.

I love that several of the keynotes this time around had a focus on observability, with talks from Honeycomb’s Christine Yen, eBay’s Vijay Samuel, and Dah0’s Kasper Borg Nissen. It’s been really cool to see how Observability has taken a bigger and bigger role in recent conferences. For example, this year’s Southern California Linux Expo (ScALE) had a dedicated observability track for the first time. KubeCon also has a dedicated observability track, and the Observability Day co-located event now has two tracks. Observability is definitely here to stay!

OpenTelemetry Observatory and Humans of OpenTelemetry interviews

The OpenTelemetry Observatory was back in the Solutions Showcase for a fourth time. I love the OTel Observatory because it provides a great space for OTel practitioners to connect with community members. Since KubeCon NA 2024, it has also included a display panel listing the top OTel individual contributors and contributing organizations. I spotted my own GitHub user handle, avillela, among the top individual contributors, along with Dynatrace as one of the top contributing organizations! So cool!

The OTel Observatory is also where we’ve conducted the Humans of OTel interviews since KubeCon Chicago in 2023. Shot over two days, fellow OTel End User SIG maintainer, Reese Lee, and I interviewed a number of OTel practitioners and contributors, including our very own Mikko Viitanen, who’s the product manager of our Dynatrace OTel team! Fellow Dynatrace DevRel Henrik Rexed lent us his filmmaking and production talents to help make this top-notch! I can’t wait to share the interviews once Henrik and I are done doing all of the editing in the next couple of weeks.

Humans of OpenTelemetry livestream

Last KubeCon (Salt Lake City 2024), we also introduced the Humans of OTel livestream, in which Reese Lee and I interview an end user and someone from OTel leadership. This time around, we interviewed Grafana’s Marylia Gutierrez (former end user and current OTel approver and maintainer) and Honeycomb.io’s Austin Parker (OTel Community Manager).

Marylia talked about her journey in going from end user in her former role at Cockroach Labs, to OTel approver and maintainer, in her current role at Grafana Labs. She also talked about the localization work she’s doing, helping to translate the OTel docs into Portuguese as part of a larger effort to make the OTel docs available in a variety of languages. Fun fact: the OTel docs are now available in English, Spanish, French, Japanese, Portuguese, and Chinese!

Austin talked about OTel’s past, present, and future, and shared some of the latest and greatest project updates (more on that shortly).

OpenTelemetry Project Updates

I’ve tried to make a point of attending the OpenTelemetry (OTel) project updates since KubeCon EU 2023 in Amsterdam. I remember we were crammed into a small conference room. It was hot, stuffy, and people were overflowing into the hallway. This time around, there was a big room to match our big audience. Some highlights:

• Project growth:
  • Contributions have seen a steady growth since the project’s inception in 2019
  • The project has seen 1000+ contributions across different organizations (fun fact: Dynatrace has been one of the top contributors since the project’s early days)
• Graduation status:
  • Graduation prerequisites have been fulfilled, so it’s only a matter of time before the project achieves graduated status with the CNCF. Who knows…maybe we’ll see an announcement at one of the upcoming KubeCons this year! 🤞
• Certification and education:
  • The OpenTelemetry Certified Associate (OTCA) is in beta, and will be in GA (general availability) soon!
  • Available for FREE: the Linux Foundation has a Getting Started with OpenTelemetry course
• Surveys:
  • One of the End User SIG’s mandates is to share end user feedback with the various project SIGs. We’ve achieved this by partnering with project SIGs in the last year to help put out surveys to the OTel community. These help drive SIG roadmaps for the coming year. A huge thanks to the 551 responses that we’ve had across 6 surveys since March 2024.
• Other updates:
  • The OTel Collector now supports profiling with the service.profileSupport feature gate, supported by 12 components!
  • At the KubeCon NA OTel Project Updates, the team introduced an OpenTelemetry user-facing logs API. This API is now part of the OTel Specification. The Logs Bridge API will coexist with the Logs API.
  • The OTel Collector has 43 new components, and a number of core modules have been marked as 1.x.

Main KubeCon EU 2025 talks

In addition to my Observability Day talk, I also gave not one, but TWO talks at the main conference.

How Green is My OpenTelemetry Collector?

My first talk on Wednesday, April 2nd, was called How Green is My OpenTelemetry Collector? In this talk, Nancy Chauhan and I explored using the CNCF’s Kepler project to tune the OTel Collector to lower its carbon footprint. We covered how to install Kepler and configure the OTel Collector to send telemetry data to an Observability backend and how to analyze the data emitted by Kepler to help you tune the OTel Collector to make it more energy-efficient. I used Dynatrace dashboards, powered by DQL, to help me analyze the data.

I met Nancy last year at KubeCon EU in Paris. As an active member of TAG Environmental Sustainability and founder of Women in Cloud Native, she was the perfect partner this talk! A huge thanks to everyone who attended. We were the last talk of the day, so I always appreciate it when people stick around that late. And a huge shout out to Henrik Rexed, who previously did a TON of work on Kepler, and whose help was instrumental in helping us put this talk together. You can check out some of his previous work on Kepler here.

OTel Me How to Get My Open Source Community Taken Seriously

My second talk took place on Thursday, April 3rd, and was called, OTel Me How to Get My Open Source Community Taken Seriously. This time, my co-speaker was Reese Lee. Our talk was about how we built out the OTel community via the OTel End User SIG. She and I are maintainers of the SIG, alongside Dan Gomez Blanco. Our talk highlighted the things that make the OTel community special, and how we keep that community going through the End User SIG. The End User SIG is responsible for connecting end users, which we do through our regular monthly sessions, OTel Me… and OTel in Practice.

We also help bring end user feedback to OTel maintainers, which we do by partnering with various project SIGs to administer surveys. They help drive the direction and roadmap for the various OTel SIGs, ensuring that they include features that benefit the end users.

As with Wednesday’s talk, this talk was near the end of the day, so again, I am super grateful for the folks who made it out. I was pleasantly surprised to see a number of OTel contributors attending the talk, which made my day!

Reese and I have spoken together several times over the past couple of years: at KubeCon, Open Source Summit, Observability Day, and All Things Open. She’s a wonderful talk partner because we think and work the same way. Also, her cat, Taco, makes THE BEST slide model.

Final thoughts on KubeCon EU 2025

After three talks in three days and three recording events, I was exhausted, but I had a blast. I come away from every KubeCon with an immense feeling of gratitude: for the opportunity to speak and share my knowledge, for being able to personally connect with members of the OTel community, and for getting to see many good friends from across the globe in a single place.

Got the post-KubeCon blues? Check out Dynatrace’s KubeCon recap livestream recording, featuring Henrik Rexed, Alexantra Oberaigner, and me.

I’ll be speaking again at KubeCon Japan in mid-June, so if you’re around for that conference, please come and say hello!

If you want to learn more about Dynatrace and OpenTelemetry, check out these resources.

• Dynatrace Loves OpenTelemetry
• How to send OpenTelemetry data to Dynatrace
• Check out our video series, “Dynatrace Can Do THAT with OpenTelemetry?” In it, my teammate Andi Grabner teaches me all sorts of cool things that Dynatrace can do with OpenTelemetry data ingested into Dynatrace via the OTel Collector.
  • Episode 1: Services
  • Episode 2: Traces
  • Episode 3: Logs

The post KubeCon EU 2025 retrospective: Reflections from my sixth KubeCon appeared first on Dynatrace news.

Managing Kubernetes environments can be challenging due to their distributed and ephemeral nature. This makes it difficult to easily find the information you need to ensure your environments are stable, efficient, and scalable. A common tool to stay on top of this challenge is dashboards, as they allow you to display the most important signals in one place and allow for easy customization. Especially in the open-source community, dashboards are the go-to tool for monitoring and optimizing Kubernetes environments.

When troubleshooting, having all your data in one place, especially in one view, is critical. While dashboards provide an easy means to see all signals in one place, setting up and scaling data management is a huge challenge for many teams relying on open-source monitoring solutions. Most of the time, teams end up with dashboards that show signals only from a small subset of their overall Kubernetes environment.

That’s why we built our ready-made dashboards utilizing the context-rich data provided by Dynatrace Grail™, the only causational data lakehouse with massively parallel processing. With Grail, you truly get all your data in one place while still being able to easily customize it to your preferences.

New Dynatrace dashboards for Kubernetes give platform engineers a more intuitive and optimized experience with the look and feel they already know and love.

Seamless Dynatrace experience

Easy dashboard customization is key, giving you a seamless Dynatrace experience and allowing you to harness the full power of the Dynatrace platform. With Dashboards, you can see both the Kubernetes data you want and the observability data you need within the Dynatrace platform. As all data is connected within the Dynatrace platform, you can seamlessly jump from viewing namespaces in a dashboard to their respective details within the Kubernetes app and vice versa. This allows for highly efficient navigation throughout Dynatrace, ultimately allowing you to find the information you’re looking for much faster than in any other tool. Of course, this applies to Kubernetes and any data residing in Dynatrace. The opportunities are limitless. Put Kubernetes and tracing data together with log and event data. Choose only the data and capabilities you and your team need. Design your dashboards with the exact data you need to ensure you’re working optimally from a single view.

How it works

The Kubernetes ready-made dashboards show you the most crucial information from your Kubernetes environment. From there, it’s easy to customize them to your personal preferences. Start with one of the platform’s base dashboards and customize it to your needs. With just a few clicks, you can add platform app data directly to your dashboards. For example, quickly add related logs of workloads to your dashboard directly from the Kubernetes app, as shown below.

Rather than starting with a blank page, you can easily add or remove what you need or don’t need for any scenario. Today, we provide you with the five most used dashboards for Kubernetes observability:

• Kubernetes Cluster: Get broad visibility into the scale, status, and resource usage of your Kubernetes clusters.

• Kubernetes Nodes – Pods: Understand pod resource consumption on your Kubernetes nodes.
• Kubernetes Namespace – Workloads: Explore the resource utilization distribution across workloads in your namespace.
• Kubernetes Namespace – Pods: Analyze resource allocation of all pods within a namespace.
• Kubernetes Persistent Volumes: Inspect the utilization and size of your persistent volume claims.

Get started

There’s no time like the present to get all your data quickly and easily on one dashboard. Check out the ready-made dashboards in the new Kubernetes platform monitoring solution in the Dynatrace Playground today.

The post Level up your Kubernetes experience with new Dynatrace dashboards appeared first on Dynatrace news.

After a decade of helping companies manage container orchestration, Kubernetes, the open source container platform, has established itself as a mature enterprise technology. According to the Cloud Native Computing Foundation (CNCF), 84% of organizations are using or evaluating Kubernetes, up from 81% in 2022.

But challenges remain when it comes to Kubernetes complexity. The average deployment now spans 20 clusters running 10 or more software elements across clouds and data centers. In fact, 76% of technology leaders say the dynamic nature of Kubernetes makes it more difficult to maintain visibility of their infrastructure compared with traditional technology stacks.

With Kubernetes, it’s easy for many organizations to miss the forest for the trees. While its open source attributes have helped establish it as the industry standard for deploying, managing, and scaling container-based applications, its complexity rapidly increases as Kubernetes deployments begin to scale.

This was the case for PicPay, a financial services app in Brazil. I spoke with Martin Spier, PicPay’s VP of Engineering, about the challenges PicPay experienced and the Kubernetes platform engineering strategy his team adopted in response.

Overcoming Kubernetes complexity

With more than 35 million active users, PicPay is experiencing substantial growth: In 2023, the Total Payment Volume jumped 40% to R$271 billion, while revenue reached a record of R$3.5 billion.

The company receives tens of thousands of requests per second on its edge layer and sees hundreds of millions of events per hour on its analytics layer. To manage this data, PicPay has more than a hundred Kubernetes clusters running tens of thousands of pods and over a thousand microservices. “We ended up with allegedly the largest cluster in Latin America” Spier said, “which isn’t a great thing”.

Moreover, observability of their increasingly complex Kubernetes environment was lagging. “Our development teams relied heavily on logs to understand what was going on with our systems,” he said. This created problems with both visibility and scalability. Different teams were using different solutions to achieve the same results, creating a fragmented IT stack. In addition, their logs-heavy approach to analysis made scaling processes complex and costly. By over-rotating on log analysis, Spier and his team were missing the value, cost savings, and productivity that come from having metrics, traces and logs all in one place and in context.

To address these problems, Spier and his team needed to simplify. “We decided to break up the big cluster into smaller ones and create a standardization to provide that managed infrastructure for everyone,” Spier said. The company’s goal was to standardize observability and prevent common problems, such as Java or pods running out of memory, or users requesting resources and barely using any, or using 100% of it.

Taking a strategic Kubernetes platform engineering approach

Spier noted that keeping Kubernetes simple requires a strategic approach. He points to the shift from DevOps to platform engineering, or as he calls it, Foundation Engineering.
“Software is built in layers,” Spier explained. “And these layers tend to be similar. But if every team is left to define their own tools and stacks, you end up duplicating a lot of the work. Platform engineering looks to bring in a unified toolset.”

Spier also noted that trying to support all possible use cases is another common pitfall in navigating Kubernetes complexity. “For example, if most teams run Java, it might not make sense trying to support an outlier. Instead, you’re better off creating the best solution for the common use case.”

Ultimately, the sooner companies start controlling complexity using a standardized Kubernetes platform engineering approach, the better. “Start before you have multiple, competing platforms and you have to go through a really unpleasant migration,” Spier suggested.

Unified observability is a team sport for taming Kubernetes complexity

To implement their Kubernetes platform engineering strategy, PicPay needed observability of the big picture. They also needed to integrate the value and context of metrics and traces into their log monitoring scheme in a single place. To achieve it, Spier and his team turned to Dynatrace.

PicPay’s partnership with Dynatrace has enabled Spier and his team to accelerate their platform engineering efforts, which has resulted in several key benefits, including the following:

• Metrics, traces, and logs in one place. The Dynatrace platform integrates all data in one place and in context.
• Immediate entry. Dynatrace supports most tools and languages out of the box.
  Automated notifications. The solution offers automatic alerts and the ability to create alert baselines.
• Ease of use. All relevant data is in the same place under a single control plane with a unified view.
• Complete visibility for Kubernetes. Since all PicPay workloads run on Kubernetes, the company can detect issues before they happen.
• Cost efficiency. By consolidating many tools into a single platform solution, PicPay saves on costs and maintenance, preserving developer time for innovation.

The post A Kubernetes platform engineering strategy tames Kubernetes complexity appeared first on Dynatrace news.

As with all new tech, implementation and understanding don’t occur overnight. The adoption process takes time and consideration. While more investments are being directed towards Kubernetes-native or cloud-native methods, the challenges in using Kubernetes remain. Its complex, distributed nature makes it difficult to use and understand.

Monitoring cluster health is critical for ensuring that applications operate efficiently and reliably. However, the complexity and numerous moving parts of Kubernetes multicloud clusters mean that platform engineers often struggle when monitoring cluster health. This creates a lack of insight into Kubernetes platform health and the potential issues that can arise.

Gain comprehensive observability of your Kubernetes clusters

As organizations continue to adopt Kubernetes-centric infrastructure, it’s increasingly crucial that platform engineers have the right tools and capabilities to properly manage and track their Kubernetes clusters end-to-end.

The new Dynatrace Kubernetes experience provides a 10,000-foot view of all Kubernetes clusters across all environments and distributions from GCP, Azure, and AWS to OpenShift or on-premises solutions. With the Kubernetes experience, platform engineers can look across and drill down to quickly identify problem nodes, issues, and the underlying root causes for faster mean time to resolution (MTTR).

For any organization, maintaining a fast MTTR and customer happiness is critical. The enhanced web UI and out-of-the-box health signals give engineers the ability to easily understand which clusters are experiencing issues and negatively impacting customer experience. Additionally, the auto-baselining of performance and automated alerts allow engineers to understand issues within any of their clusters before they become serious or result in outages.

All the data a platform engineer needs to understand what’s going on can easily be seen in one place. This is a revolutionary improvement for platform engineers and R&D teams in general. What used to take a lot of valuable time, resources, and tools is now available in one central place.

When working with Kubernetes, it’s imperative to carefully keep track of what is going on in your clusters to ensure optimal health and efficiency. For instance, pods of misconfigured workloads can render the nodes they are running on unhealthy. Such critical situations are signaled by warning events and unhealthy node conditions. Engineers get a detailed view of a single cluster status, providing insight into the relevant Kubernetes health signals of container resources like nodes, namespaces, and workloads.

The new Dynatrace Kubernetes experience allows engineers to easily drill down to their unhealthy workloads, investigate ongoing issues, and gather all information required to fix problems quickly. If an unhealthy workload is owned by another team, having access to the provided ownership information enables engineers to promptly notify the correct team, ensuring a faster, more efficient resolution process.

Optimize resource utilization across workloads

In addition to the complexity that makes assessing the ongoing state of cluster health challenging, engineers face the issue of runaway cloud costs due to inefficient resource utilization. Platform engineers size their Kubernetes clusters based on the workload’s resource requests. As these engineers often manage a large fleet of clusters, node-scalers are frequently used to automate the task of dynamic optimization. However, if workload owners underutilize the requested resources, the platform wastes an incredible amount of unused resources, leading to an unnecessarily high carbon footprint and soaring cloud costs.

The ability to switch to the resource perspective helps engineers to easily assess the current state of resource efficiency of their Kubernetes environments. This allows for a fast drill-down to determine the workload contributing most to the situation, whether it’s CPU or memory waste. By using the available ownership information, teams can quickly and immediately begin to collaborate on optimizing these workloads.

Onboarding is faster than brewing a cup of coffee

Onboard a new Kubernetes cluster in three minutes. Yes, it only takes three minutes to activate Dynatrace Kubernetes Observability. It doesn’t matter which distribution you use, and no documentation is needed.

During onboarding, you can easily and seamlessly add Dynatrace Application Observability functionality like automated distributed tracing and code-level visibility to enhance workload health and performance.

Good product experiences go hand-in-hand with good pricing

That’s why the full Kubernetes Observability experience—which includes Kubernetes monitoring and application observability—is set at a price that is simple and transparent. Pricing relies on two key pillars:

• Predictable pricing for monitoring Kubernetes cluster health based on pod-hours. The longer a pod is monitored, the more pod-hours are consumed. Dynatrace pricing is independent of pod sizes or the number of nodes. It seamlessly works with all types of Kubernetes environments, whether they are fully managed (for example, GKE-Autopilot, EKS, AKS) or self-managed (on-premises or in the cloud).
• Flexible, consumption-based pricing for applications running on Kubernetes. Pricing is based solely on the memory used by the containerized applications that you are monitoring. Dynatrace Kubernetes cluster onboarding is rolling out its Full-Stack Monitoring mode in such a way that OneAgent code modules are only deployed to selected application pods.

All this is done automatically, simply, and conveniently. So, stop waiting. Embrace the experience of Dynatrace’s comprehensive Kubernetes observability offering and gain insights into your running workloads, pods, containers, and more.

What’s the next step in ensuring your Kubernetes health?

• The Kubernetes Observability app requires the latest Dynatrace platform, powered by Grail™, and a Dynatrace Platform Subscription. For more details, take a look at this blog post in the Dynatrace Community.
• You can find out more about the Kubernetes app in Dynatrace Documentation. For monitoring consumption documentation, see Container monitoring (DPS).
• Want to try it for yourself? Check it out here.

The post Kubernetes health at a glance: One experience to rule it all appeared first on Dynatrace news.