What is APM?

Application performance monitoring (APM) is the practice of tracking key software application performance metrics using monitoring software and telemetry data. Practitioners use APM to ensure system availability, optimize service performance and response times, and improve user experiences.

Research firm Gartner defines APM this way:

“Application performance monitoring is a suite of monitoring software comprising digital experience monitoring (DEM), application discovery, tracing and diagnostics, and purpose-built artificial intelligence for IT operations.”

In today’s digital markets, ensuring an application is always operating at peak performance is essential. The connection between a user’s experience with the back-end services supporting its functions is not always clear, which is especially true with distributed cloud-native applications. To address these ambiguities, APM enhanced by AI greatly increases the efficiency of analyzing application dependencies and how each component affects the other.

APM provides insight into how users experience applications and where performance gaps lie. Mobile apps, websites, and business applications are some examples of front ends that APM can monitor, providing insight into an application’s user experience. APM also includes supporting elements, such as hosts, processes, services, the network, and logs, to foster additional understanding of application performance.

Application performance monitoring vs. application performance management

In addition to application performance monitoring, APM also stands for application performance management.

While application performance monitoring focuses on specific metrics and measurements, application performance management is the wider discipline of developing and managing an application performance strategy. Both these terms refer to related technology and practices.

Observability vs. monitoring

True to its name, APM is about monitoring application performance and system health by capturing and displaying data that teams then analyze using various means. Monitoring focuses on individual metrics that can indicate specific problems.

Observability, on the other hand, ascertains a system’s internal state based on the data it generates, such as logs, metrics, and traces. With this additional granularity, observability can determine the root cause of problems and realize their effects. Using this telemetry data, observability captures the context of what’s happening across multicloud environments so teams can detect and resolve the underlying causes of issues.

The highly distributed nature of modern cloud environments requires that an effective APM solution take a holistic observability-based approach.

What does APM do?

APM has rapidly expanded to encompass a broad range of capabilities, technologies, and use cases to keep pace with cloud-native IT environments.

Continuous improvement

APM can assist teams in optimizing application performance, reliability, and response times by providing the necessary metrics and data for continuous improvement. By using APM to acquire key data points relating to application performance, such as user interaction patterns, application bottlenecks, and software issues, teams gain a greater understanding of where to concentrate efforts and resources for enhancing applications.

Cloud resource utilization

Moreover, APM assists in managing cloud spend and meeting sustainability goals by identifying where organizations can consolidate and optimize resource utilization and consumption.

Application security

APM also enhances application security, a crucial aspect of preserving business value and delivering secure user experiences, by identifying software vulnerabilities and abnormal or suspicious activities.

AI model performance

Amid the increasing prominence and necessity of AI-driven services, APM can also monitor the performance of AI models embedded in applications. AI model monitoring helps ensure that organizations can predict and control AI costs, performance, and data reliability.

Why do organizations need APM?

Every day, customers use apps to shop, work, stream shows and movies, connect to social media, and manage finances. When an app crashes, is slow to load, or doesn’t load at all, users become frustrated, which can cause the business to suffer brand damage or lose revenue. When an internal business application begins to falter, the company may also see reduced employee productivity.

Discover problems before they disrupt

By monitoring systems at the level of metrics, logs, and traces, an advanced observability-based APM solution can discover problems before they disrupt operations or cause outages. observability metrics can establish a performance baseline and detect variances that could lead to wider problems.

Determine the root cause of issues

If an issue does occur, digital teams often find it difficult to identify the root cause of an application performance problem. Causes can run the gamut, from coding errors to database slowdowns and hosting or network performance issues. Even a conflict with the operating system or the specific device being used to access the app can degrade an application’s performance. Observability-based APM can pinpoint and help teams to prioritize these issues.

Cut through cloud complexity

While modern applications such as mobile apps, websites, and business apps may seem simple on the surface, they’re highly complex. These apps comprise millions of lines of code. They include hundreds of interconnected digital services and open source solutions, and they run in containerized environments hosted across multiple cloud services. Without APM technologies, teams struggle to resolve the numerous problems that can arise, raising the likelihood of customers getting frustrated and abandoning the app altogether.

For this reason, a powerful APM solution based on end-to-end observability is necessary to properly maintain and optimize modern applications.

APM core features

APM encompasses many types of monitoring across the full IT stack, including the following, among others:

• Infrastructure monitoring
• Network monitoring
• Database monitoring
• Log monitoring
• Container monitoring
• Cloud monitoring
• Serverless monitoring
• Synthetic monitoring
• End-user monitoring

Organizations often run dozens of individual monitoring tools at once, especially when they’re holding onto legacy applications and managing them using the tools they find most familiar.

Although individual tools may seem easier, especially to meet the needs of many teams, fragmented monitoring frequently creates problems. A single APM solution that takes a full-stack observability approach makes monitoring all these use cases easy and more reliable.

What are the benefits of APM?

Observability-based APM provides modern IT operations with numerous benefits, including the following.

Full-stack observability

As application infrastructures expand to encompass both on-premises and multicloud environments, organizations increasingly understand that only a full-stack observability approach can deliver comprehensive visibility into the root causes of issues, wherever they originate. Teams can monitor their entire infrastructure from end to end—encompassing everything from infrastructure health to application performance and even the end-user experience. With this visibility, teams can see all these components and understand the interdependencies among them, getting faster answers to key questions.

Continuous automation

Trying to manually maintain, configure, script, and source the volume of data in a cloud-native environment is beyond human capabilities. Therefore, organizations must continuously automate these tasks to ensure proper application performance. Processes including deployment, configuration, discovery, and updates require automation to keep pace with modern multicloud environments and user demands. For this reason, an APM solution that continuously informs and automates every touchpoint of the software development lifecycle (SDLC) and other business processes is crucial to maintaining efficiency.

AI assistance

AI assistance empowers teams by reducing manual or redundant work, allowing them to be more productive in areas of critical importance to the business. An observability-based APM solution that provides multi-tiered AI capabilities goes beyond just collecting data by using that data for real-time answers. A successful APM solution uses predictive, causal, and generative forms of AI in tandem to proactively resolve problems and improve performance without the need for extensive manual effort.

Cross-team collaboration

APM is a team sport, typically requiring the expertise of multiple teams. When organizations can depend on a unified observability-based platform as a single source of truth, teams can break down silos and achieve greater cross-team collaboration. When business, operations, application, and development teams are working from the same data sets, they can streamline communication and reach decisions quickly to resolve problems and optimize applications.

User experience and business impact

User experience is inextricably linked to business outcomes, whether the application is mobile app-to-user, IoT device-to-customers, or a web application behind the scenes. With intelligence into user sessions, including real user monitoring and session replay, teams can connect user experiences to application performance and business outcomes such as increased conversions, revenue, and completed customer journeys.

Synthetic monitoring also enables teams to proactively resolve issues and optimize applications by simulating artificial user interactions, which can ensure optimal user experience before any real issues occur.

With data-backed decisions, answers at the ready, and real-time visibility into user journeys and business key performance indicators (KPIs), organizations can consistently and more efficiently deliver ideal customer experiences across all their channels for better business outcomes.

The technical, operational, and business benefits of APM

APM provides specific benefits for technical, operations, and business teams.

APM technical benefits

Business, operations, application, and development teams can expect several practical benefits from adopting APM practices and tools, including the following:

• Increase application stability and uptime by AI-powered root-cause analysis and real-time answers
• Reduce performance incidents with proactive alerting
• Speed up and automate performance problem resolution
• Accelerate and increase the quality of software releases with automated development and delivery processes

APM operational benefits

Long-time users also report that APM has given their organizations some unexpected but impactful advantages. Operational benefits include the following:

• Increase collaboration across teams with a single source of truth
• Boost confidence to make well-informed and impactful business decisions for teams across the organization with new insights and reliable intelligence
• Increase efficiency and innovation for application, operations, and development teams for faster issue resolution
• Bolster job satisfaction and higher employee retention among team members

APM business benefits

Those in the boardroom have just as much to gain from adopting APM solutions as those on the front lines of DevOps efforts. Business benefits include the following:

• Reduce operational costs with greater automation and efficiency
• Upgrade developer and operational productivity by facilitating cross-team collaboration
• Improve customer experience by increasing understanding of end users and their preferences
• Increase conversion rates from improved application stability and optimized user experience
• Achieve sustainability goals with greater insight into the IT carbon footprint

However, modern cloud-native environments present challenges for APM solutions that require specialized capabilities to achieve these benefits.

Why do cloud-native applications make APM challenging?

Even though the benefits of APM are well established, the rise of complex cloud-native applications has made it more challenging for organizations to perform well and remain competitive.

Massive amount of telemetry data

For example, cloud-native apps generate far greater quantities of telemetry data because they are made up of myriad microservices that dynamically spin up and down in the background. Each of these microservices exists for a short period and generates its own telemetry data, adding to the overall signal noise. When this happens, it becomes more difficult to find the most important events taking place within an application’s infrastructure.

Distributed cloud architectures

What’s more, the distributed and dynamic nature of microservices often makes it difficult to pinpoint the root cause of issues without the assistance of a reliable AI engine. As a result, strong AI capabilities are a necessity for cutting through the noise and garnering meaningful answers relating to problem remediation and application optimization.

Heterogeneous data

Cloud-native apps also produce many kinds of data. Telemetry data from a serverless environment is quite different from a database or a virtual machine (VM), for example. But an organization still needs to centrally manage and make sense of all the information as it comes in.

Increased velocity

The velocity at which systems generate this data is another problem. When a cloud-native app includes many smaller microservices, data comes in at a much faster rate than with a monolithic application. All these factors add challenges that make traditional APM more difficult in a cloud-native application environment.

APM tools vs. APM platforms

Though often referred to as one in the same, both APM tools and APM platforms offer unique benefits that teams can apply based on an organization’s needs, use cases, and resource availability.

What are APM tools?

APM tools are software utilities that often focus on one specific aspect of application performance. Such point solutions can help identify specialized issues. Over time, however, organizations often find themselves using multiple APM tools that don’t necessarily integrate with one another or provide comprehensive insights into the application environment.

In response to the rapid influx of telemetry data, organizations can take one of two approaches when picking APM tools. By default or by design, different teams may deploy a combination of point solutions—tools that solve only one business problem. Conversely, they may choose a single platform that more fully encompasses the many layers and use cases within the application environment.

What is an APM platform?

An APM platform is a software system that provides a single integrated solution using AI and automation to deliver a precise, context-aware analysis of the application environment. Organizations can use an APM platform to continuously monitor the full stack for system degradation and performance anomalies.

With the deluge of telemetry data associated with cloud-native apps comes a profusion of performance monitoring tools and platforms. In response, organizations are turning to open source standards and tools, such as OpenTelemetry, to standardize how they instrument, generate, and collect telemetry data for analysis. However, to thoroughly analyze the data such tools gather, the tools often must be complemented by an observability-based APM platform. This combination can provide valuable insights into software performance and behavior across multiple cloud platforms and tools.

Point solutions can pose benefits at a local level and challenges at a macro level, while a platform approach embraces a modern vision of APM that demonstrates clear advantages at the local and macro levels. What’s more, a platform approach also streamlines and simplifies business and technical processes, enhancing collaboration across teams.

Benefits of individual APM tools

Individual APM tools are specialized to monitor specific components and provide advantages for those specific use cases. For example, some organizations use Grafana to consolidate their metrics visualizations in a single dashboard while others use Jaeger for its distributed tracing capabilities to gain better observability of their systems and troubleshoot performance issues. Both these tools are highly specialized for the environments to which they’re applied.

Teams focused on solving a specific, specialized issue, such as implementing a service mesh to help manage orchestration in their Kubernetes environment, turn to individual tools because they’re cost-effective and easy to implement.

Challenges of individual APM tools

Individual tools only provide a limited view of an organization’s application architecture. This limited visibility makes it harder to identify root causes of application performance issues, resulting in longer downtimes when problems arise. Further, they only provide a single view of the application architecture, often missing the “cause and effect” of performance problems—for example, increased CPU usage caused by a microservice failure. This limited visibility may result in unnecessary troubleshooting exercises and finger-pointing, not to mention wasted time and money.

Because the scope of these solutions is limited, they can also create silos in which teams may disagree on service-level objectives (SLOs) and metrics. This silo effect can lead to more inefficiency and blame-shifting, as teams rely on different sets of information.

APM as part of a larger multicloud observability strategy

Because APM has its roots in the era of monolithic applications before the rise of microservices, open source technologies, and cloud-native environments, some industry observers have argued that APM platforms lack the innovation and deep-dive capabilities required to keep up with bespoke point solutions and individual tools. This may be true for many traditional APM monitoring tools.

However, an observability-based platform such as Dynatrace can offer broad technological coverage across the full stack, including bespoke point solutions.

Purpose-built for cloud-native environments

By leveraging data capture for any type of application and APIs to ingest data, a cloud-native platform like Dynatrace can broaden its coverage to the entire hybrid-multicloud network. This provides a macro-level view across multiple environments to provide continuous discovery. Visibility extends to the applications running within these environments, providing proactive anomaly detection prioritized by business impact.

AI and continuous automation

Crucial capabilities of a modern APM platform include AI and continuous automation. With the explosion of observability data, a platform needs to automatically process billions of dependencies in real-time, continuously monitor the full stack, and deliver precise answers with root-cause determination. Dynatrace takes a power-of-three approach to AI that leverages predictive, causal, and generative AI to help organizations deliver the highest software performance and enable workflow automation.

Integration with cloud platforms

With the scale, diverse functionality, and dynamic nature of cloud platforms such as Amazon Web Services, Microsoft Azure, and Google Cloud Platform, successful APM solutions need to work immediately without configuration or model training. The Dynatrace platform provides complete observability out of the box for dynamic cloud environments, at scale and in context.

By going beyond metrics, logs, and traces with AI-powered analytics, Dynatrace provides automated and intelligent answers from data across the full stack, including entity relationships, user experience data, cloud services, and the latest open source standards, including OpenTelemetry.

The future of APM

APM has always played a crucial role in optimizing digital business, but the recent influx of rapid AI innovations has rendered unified, holistic APM especially crucial. AI introduces new monitoring challenges that require teams to understand their expanding applications to maintain efficient operations and a positive user experience. But achieving this level of understanding can be difficult due to the complexity of generative and agentic AI stacks. As a result, auto-discovery and AI-powered answers are essential to help resolve issues when they arise. Teams need a reliable way to cut through the noise with an efficient, unified approach to problem remediation and application optimization.

The increasing size and complexity of AI workloads have also grown past human ability to manage. For this reason, automating as many processes as possible (with an end goal of fully autonomous operations) is the most reliable way to meet the demands of modern AI workloads. However, autonomous operations are only as effective as the answers they rely on. These answers must be deterministic and exact, not based on causation. APM equipped with deterministic AI is key to facilitating effective autonomous operations, enabling meaningful action based on answers, not guesses.

The post What is APM? Application performance monitoring in a cloud-native world appeared first on Dynatrace news.

OpenTelemetry is an open-source framework of tools, APIs, and SDKs that help analysts understand software performance and behavior. Also referred to as OTel, OpenTelemetry is rapidly solidifying its position as a fundamental tool in the world of observability.

Born as an open-source project under the Cloud Native Computing Foundation (CNCF), OpenTelemetry provides a unified framework for generating, collecting, processing, and exporting telemetry data—including logs, metrics, and traces.

Using OpenTelemetry,  IT teams can instrument, generate, collect, and export telemetry data for analysis to better understand software performance and behavior. When OpenTelemetry debuted in beta in 2020, it replaced its predecessors, OpenTracing and OpenCensus.

OpenTelemetry enables observability

To appreciate what OTel does, it helps to understand observability. Traditionally speaking, observability is the ability to understand what’s happening inside a system from the knowledge of the external data it produces; usually logs, metrics, and traces.

But the data itself is only as good as what you can learn from and do with it. This definition from Hazel Weakly sums it up nicely:

“Observability is the ability to ask meaningful questions, get useful answers, and act effectively on what you’ve learned.”

Observability is important because the systems of today are exponentially more complex than the systems of ten, or even five years ago. The shift from monolithic to distributed IT architectures introduces many more moving parts and interactions to keep track of, sometimes leading to systems behaving in unpredictable ways. Observability helps you make sense of what’s happening so you can act on this information, and OpenTelemetry helps to enable observability.

By promoting consistency and interoperability, OpenTelemetry enhances observability practices and benefits the entire industry by streamlining and standardizing how everyone can collect and use data.

Since the project’s start, many vendors, including Dynatrace, have contributed to the project to make rich data collection easier and more consumable. In fact, Dynatrace is one of the top contributing organizations to OpenTelemetry.

Benefits of OpenTelemetry

Collecting application data is nothing new. However, the collection mechanism and format are rarely consistent from one application to another. This inconsistency can be a nightmare for developers and Site Reliability Engineers (SREs) who are just trying to understand the health of an application.

Most of the major observability vendors, including Dynatrace, support OTel. As a result, it has become the de facto standard for instrumenting cloud-native applications. What differentiates observability solutions from one another is what they do with your data to help you ask the right questions. Asking the right questions unlocks an elevated level of understanding, giving businesses the ability to accelerate growth, drive innovation, and deliver experiences customers love.

It’s akin to how Kubernetes became the standard for container orchestration. This broad adoption has made it easier for organizations to implement container deployments since they don’t need to build their own enterprise-grade orchestration platform. Using Kubernetes as the analog for what it can become, it’s easy to see the benefits it can provide to the entire industry.

To understand why observability and OTel’s approach to it are so critical, let’s take a deeper look at telemetry data itself and how it can help organizations transform how they do business.

What is telemetry data?

Telemetry is the process of gathering and transmitting signals (data) emitted by instrumentation code within a system’s components. Traces, metrics, and logs make up most of all telemetry data.

• Traces result from following a process (for example, an API request or other system activity) from start to finish, showing how services connect. Keeping watch over this pathway is critical to understanding how your ecosystem works, if it’s working effectively, and if any troubleshooting is necessary. Traces consist of individual operations called spans, which include unique identifiers, such as operation name, timestamp, context, attributes, events, and status.
• Metrics are numerical data points, either counts or measures, that systems can calculate or aggregate over time. Metrics originate from several sources, including infrastructure, hosts, and third-party sources. While logs may not always be accessible, most metrics are readily available via query. Timestamps, values, and even event names can preemptively uncover a growing problem that needs remediation.
• Logs are important because you’ll naturally want an event-based record of notable anomalies across the system. Structured, unstructured, or plain text, these readable files can tell you the results of any transaction involving an endpoint within your multicloud environment. However, not all logs are inherently reviewable—a problem that’s given rise to external log analysis tools.

Telemetry data becomes observability data when, as noted above, you can “ask meaningful questions, get useful answers, and act effectively on that information.” Making sense of it all requires an observability backend.

How does OpenTelemetry work?

OTel consists of a few components as depicted in the following figure. Let’s take a high-level look at each one from left to right:

• Specification. Defines a standard telemetry data format and describes how to build instrumentation. This ensures that users have a similar experience, regardless of what language they’re using.
• Data model. Defines fields for each signal and how they interact. Signals include traces, logs, and metrics.
• API. Defines the methods used to instrument applications and serves as the entry point for instrumentation. Each language supported by OpenTelemetry has its own API implementation.
• SDK. Implements the API and also determines how systems generate and correlate their telemetry. Each language supported by OpenTelemetry has its own SDK. Both the APIs and the SDKs are defined in the specification to ensure a consistent experience across implementations.
• Collector. A vendor-neutral binary used to ingest, transform, and export data to one or more observability backends.
• OpenTelemetry Protocol (OTLP). A vendor—and tool-agnostic specification for encoding—transmitting and delivering OpenTelemetry data. Telemetry data emitted by the SDK uses OTLP, and many observability backends now support ingesting data in the OTLP format. For those who do not, there are exporters available that convert data from OTLP to a tool-specific format. OTLP supports both HTTP and gRPC.
• Observability backend. A system or tool where telemetry data collected by OpenTelemetry is sent, stored, and analyzed. It enables organizations to derive meaningful insights and make sense of telemetry data in a cohesive way.

Flexible API/SDK integration

You can decouple the API from the telemetry-generating code with minimal implementation. This decoupling allows your app or library to run with just the API package, without sending telemetry data to the backend. This setup acts as a placeholder until you’re ready to integrate an SDK. When ready, you can choose an SDK that best fits your needs, whether it’s the OpenTelemetry SDK, a vendor-specific one, or a custom-built SDK. This flexibility ensures you can add functionality without significant code changes.

What’s next for OpenTelemetry?

OpenTelemetry is maturing and is fast approaching its graduation as a CNCF project. Traces, logs and most parts of metrics are now considered generally available. The OpenTelemetry project’s goals extend well beyond its current offerings. Exciting initiatives are paving the way for even broader use cases, such as improving digital experiences and enabling detailed insights into application performance through code-level profiling. Let’s check out some highlights of OpenTelemetry’s exciting initiatives, all designed to take observability to the next level.

• Digital Experience Monitoring. Developers and product teams will soon be able to gather telemetry data directly from user-facing applications. This allows organizations to identify where users face lags or issues, enhancing overall app performance.
• Code-Level Profiling. OpenTelemetry is also evolving to profile application code in real-time. This provides deeper insights into how specific sections of code behave in production, helping engineers optimize critical parts of their applications.
• AI Agents. Recently, there’s been an explosion in the need for monitoring AI systems. OpenLLMetry is donating their code to the OpenTelemetry project. If accepted, it will soon become an extension of the OpenTelemetry ecosystem.

How can I contribute to the OTel community?

If you’ve been curious about contributing to OpenTelemetry (OTel) but are unsure where to begin, there are plenty of ways to get involved. Whether you’re a newcomer or a seasoned practitioner, the OpenTelemetry community offers a variety of opportunities suited to different interests and skill levels.

Some ways you can contribute to the OpenTelemetry Project include the OpenTelemetry documentation, OpenTelemetry blog, End User SIG, OpenTelemetry Demo, or a language or component-specific Special Interest Group SIG). No matter how big or small your contributions, they make a difference and are deeply valued.

OpenTelemetry veteran, Adriana Villela, wrote a great article to help you get started.

How does Dynatrace contribute to the Otel community?

Dynatrace is an active member of the OpenTelemetry community. Dynatracers hold key leadership roles as project maintainers or approvers in the following groups:

• OpenTelemetry Technical Committee
• OpenTelemetry Specification (Metrics, Semantic Conventions)
• OpenTelemetry for JavaScript
• OpenTelemetry Collector
• OpenTelemetry Demo project
• OpenTelemetry End User SIG

In fact, Dynatrace has a team dedicated to contributing to OpenTelemetry and ensuring that the Dynatrace platform integrates smoothly with OpenTelemetry data.

Dynatrace and OpenTelemetry together can deliver more value

OpenTelemetry is a key enabler in the observability space, providing a unified framework for collecting telemetry data. However, to unlock the full potential of this data and turn it into actionable insights, a powerful platform to manage, analyze, and visualize it effectively is essential.

Dynatrace is purpose-built to enhance OpenTelemetry’s capabilities. Data plus context are critical to supercharging observability, and with Dynatrace, you’re not just collecting data; you’re gaining a deep understanding of how your systems work and how to optimize them. With seamless integration, advanced analysis across telemetry data, insights into business outcomes, and predictive analytics spanning your entire stack, Dynatrace turns your OpenTelemetry data into actionable intelligence to optimize your systems.

Explore how Dynatrace can transform your OpenTelemetry data into a powerful driver of innovation and business success. Learn more with this video series on getting started with Dynatrace and OpenTelemetry.

The post What is OpenTelemetry?  An open-source standard for logs, metrics, and traces appeared first on Dynatrace news.

On July 19th, 2024, countless organizations had their operations disrupted by a routine software update from CrowdStrike, a popular cybersecurity software. The resulting outages wreaked havoc on customer experiences and left IT professionals scrambling to quickly find and repair affected systems.

A wide variety of companies and industries have suffered the effects of this incident, from delayed flights to disruptions in healthcare, insurance, and the financial industry. The ripple effects on the global supply chain have been equally significant. The crisis has emphasized the importance of having a strategy for maintaining stability and performance.

Time is of the essence in any crisis—so is having the right tools and capabilities. Although Dynatrace can’t help with the manual remediation process itself, end-to-end observability, AI-driven analytics, and key Dynatrace features proved crucial for many of our customers’ remediation efforts.

Following are some of the critical capabilities many of our customers relied on to recover from the CrowdStrike update crisis in just hours.

1. Real-time monitoring with out-of-the-box features

Real-time data and monitoring are crucial for maintaining situational awareness of IT environment stability and performance, especially during a crisis. Knowing what’s offline and which dependencies connect to mission-critical services is key to determining the impact of an incident and determining where to start remediation. Dynatrace offers various out-of-the-box features and applications to provide a high-density overview of system health for all hosts and related metrics in a single view.

Smartscape topology mapping

Dynatrace Smartscape® provides a dynamic, real-time visualization of the entire application topology so teams can quickly identify and address issues. Understanding application dependencies helps teams prioritize what to address first. For example, a good course of action is knowing which impacted servers run mission-critical services and remediating those first.

Problems application

The Problems application automatically identifies issues, collects the context behind them, and presents their root cause and impacts in a single view. Powered by Davis® AI, the app helps teams immediately see the problem’s duration, root cause, and business impact.

Dashboards and visualizations

Standard dashboards and visualizations also provide situational awareness out of the box. The following honeycomb visualization shows a healthy environment before an incident and after the incident starts. All the problems, offline hosts, databases, and failing services appear in red.

Dynatrace OneAgent full-stack and Foundation and Discovery modes

Dynatrace OneAgent provides automatic discovery and monitoring. In addition to using OneAgent for full stack monitoring of the most critical applications, Dynatrace offers OneAgent Foundation and Discovery mode. This lightweight alternative provides full coverage of an environment in scenarios where teams need cost-effective yet comprehensive monitoring. Foundation and Discovery provide essential metrics and topology discovery, making it useful to quickly identify and recover affected hosts.

Together, these technologies enable organizations to maintain real-time visibility and control, swiftly mitigating the impact of incidents and efficiently restoring critical services. They also enable companies to measure the effectiveness of their remediation activities to ensure that recoveries proceed as expected.

How out-of-the-box monitoring features helped one company recover from the CrowdStrike outage within hours

A US-based pharmaceutical company recovered its most critical systems within hours of the CrowdStrike incident using out-of-the-box real-time monitoring features. Dynatrace automatically found the hosts that were unavailable or having problems. The key information displayed on the standard Dynatrace Problems app and the Infrastructure and Operations App became the basis of their team’s remediation plan. The company was back to normal business operations as other companies continued to struggle with recovering days after the initial software push.

2. Synthetic monitoring

Synthetic monitoring is a critical tool for ensuring application reliability and performance, especially during a crisis. By simulating user interactions and running tests from various locations worldwide, synthetic monitoring provides a comprehensive view of application performance and availability. This proactive approach allows organizations to detect and resolve issues early, optimize performance, and maintain a high-quality user experience.

Organizations can use synthetic monitoring to continuously monitor API endpoints and ensure that critical user journeys perform well and meet service level agreements (SLAs). This awareness can help reduce downtime and minimize disruption, enabling swift action if an incident occurs.

Many businesses rely on third-party services, such as payment processors, content delivery networks (CDNs), and ticketing systems to get through their day-to-day operations. Even if the business isn’t directly affected by a crisis, their third-party suppliers may be, which can still disrupt their operations.

How synthetic monitoring helped one company get an early warning of the CrowdStrike impact

During the recent CrowdStrike crisis, a US life insurance provider was impacted indirectly through its third-party ticketing system. The Dynatrace synthetic monitors they used to monitor the performance of this critical third-party application immediately detected the outage when the CrowdStrike software affected the vendor’s servers.

Dynatrace created a problem notification and Davis AI determined the root cause on the vendor’s side, hours before the company publicly announced the CrowdStrike incident affected it. This advanced warning allowed the life insurance provider to execute a contingency plan and course of action much earlier than if they had to wait for the third-party provider to notify them of the problem.

3. Dynatrace Query Language (DQL)

Dynatrace Query Language (DQL) is a structured syntax for exploring, querying, and processing observability data in Dynatrace. It allows users to chain commands together to filter, manipulate, and analyze data efficiently.

As a data query tool, DQL provides flexibility and customization, allowing organizations to tailor their investigations to meet specific needs, addressing unique challenges and optimizing performance.

Using DQL, investigators can find specific answers so they can quickly identify and respond to issues, which is crucial during crises like the CrowdStrike incident.

Dynatrace Notebooks is an interactive capability that enables users across the organization to collaborate using code, text, and rich media to build, evaluate, and share insights for exploratory analytics. This ability to track and collaborate on issue details is a crucial capability in a crisis.

How DQL and Notebooks helped companies pinpoint affected systems and prioritize remediation

During the CrowdStrike crisis, a North American telecommunications provider used DQL and a notebook to create custom charts filtered by application. This helped the company prioritize remediating its most critical servers first, restoring essential services promptly.

When a major US airline began experiencing the CrowdStrike outage, its IT team also used DQL and Dynatrace Notebooks to identify which systems were no longer forwarding logs back to Dynatrace. This newfound visibility enabled the kiosk management team to focus their recovery efforts effectively.

To see an example of how to use DQL to find when BSOD issues are being written to Windows system logs, see the blog Crowdstrike BSOD: Quickly find machines impacted by the CrowdStrike issue by Dynatrace Principal Solutions Engineer Josh Wood, Ph.D.

4. Real user monitoring to understand business impact

Real User Monitoring (RUM) offers comprehensive insights into user experiences across web, mobile, and custom applications. By capturing user sessions, RUM provides a detailed view of user journeys, helping businesses understand critical actions for conversions.

When an incident occurs, Dynatrace automatically generates a problem notification. Davis AI analyzes details from the front end to the backend to identify the root cause, severity, and impact of the issue.

Dynatrace RUM also tracks application downtime, enabling organizations to calculate the cost of business interruptions and account for lost revenue. RUM offers flexible options for tracking and reporting key information, such as conversion goals. Examples include successful checkouts, newsletter signups, or demo requests. By monitoring conversion rates, businesses can estimate expected revenue to better understand the financial impact of an incident and help organizations account for lost revenue.

How Dynatrace RUM helped one company identify the business impacts of the CrowdStrike outage

For example, during the CrowdStrike crisis, a North American mortgage provider received an alert for unexpected low traffic. The problem card helped them identify the affected application and actions, as well as the expected traffic during that period. This allowed them to prioritize remediation efforts on their most critical services.

5. Using SLOs to verify recovery

Service level objectives (SLOs) are essential for maintaining and enhancing the performance of applications and services, especially during and after a crisis. Dynatrace makes it easy to create, capture, and visualize SLOs in real time. Establishing and monitoring SLOs can play an instrumental role before, during, and after a crisis.

• Before a crisis. Setting up SLOs for mission-critical services helps establish and maintain standards for availability and performance. Dynatrace AI continuously monitors these benchmarks, allowing teams to identify and address potential issues proactively.
• During a crisis. SLOs provide real-time monitoring and immediate feedback on service performance. Dynatrace AI can quickly pinpoint the root cause of issues, enabling swift resolution and minimizing user impact.
• After a crisis. SLOs ensure that application performance returns to the same standard of performance as before the incident. They play a crucial role in post-incident analysis, helping teams understand the business impact of the incident and implement improvements to prevent future occurrences.

By implementing Dynatrace SLOs, organizations can ensure robust performance management before, during, and after a crisis, leading to more resilient and reliable services.

Prepare for any crisis with observability and the right capabilities

The recent CrowdStrike crisis has highlighted the critical need for robust monitoring and observability tools. For organizations navigating disruptions, observability is crucial for rapid detection and remediation. Dynatrace offers comprehensive solutions with real-time data, synthetic monitoring, DQL querying capabilities, real user monitoring, and SLOs. These tools empower organizations to maintain stability, swiftly identify and resolve issues, and ensure the continuity of essential services.

The real-world examples of our customers demonstrate how Dynatrace monitoring solutions have enabled organizations to recover quickly and maintain operational stability, ultimately safeguarding their customer experiences and bottom lines. As we continue to lean heavily on technology for day-to-day operations, observability will be essential for navigating the complexities of an increasingly digital world.

Using Dynatrace, organizations can not only react fast to mitigate the immediate impacts of crises but also be proactive and build resilient IT infrastructure that’s prepared for future challenges.

Contact us to learn how you can gain the same situational awareness and responsiveness that enabled these customers to recover so quickly from the CrowdStrike outage.

The post CrowdStrike update: How Dynatrace helped customers recover in hours appeared first on Dynatrace news.

As organizations embrace cloud-native technologies, system architectures have dramatically increased in complexity and scale. Customer experiences are more important than ever, and as a result, IT teams face mounting pressure to track and respond to issues much faster. To address these challenges, teams are turning to observability solutions so they can proactively identify and resolve issues and automate workflows in their highly distributed and complex computing environments. But what is observability, and what do teams need to do it right?

What is observability?

In IT and cloud computing, observability is the ability to measure a system’s current state based on the data it generates, recorded as logs, metrics, and traces:

• Logs record the details of an event
• Metrics capture the numeric measurements used to quantify the performance and health of services
• Traces track how services connect from end to end in response to requests

Observability has become more critical in recent years as cloud-native environments have gotten more complex, and the potential root causes for a failure or anomaly have become more difficult to pinpoint.

Because cloud services rely on a distributed and dynamic architecture, observability may also refer to the specific software tools and practices organizations use to interpret cloud performance data.

How observability works

Observability relies on telemetry derived from instrumentation that comes from the endpoints and services in your multicloud computing environments. In these modern environments, every hardware, software, and cloud infrastructure component and every container, open source tool, and microservice generates records of every activity. The goal of observability is to understand what’s happening across all these environments and among the technologies, so you can detect and resolve issues to keep your systems efficient and reliable and your customers happy.

Implementing observability

Organizations usually implement observability using a combination of instrumentation methods, including open source instrumentation tools, such as OpenTelemetry.

Many organizations also adopt an observability solution to help them detect and analyze the significance of events to their operations, software development life cycles, application security, and end-user experiences.

As teams begin collecting and working with observability data, they are also realizing its benefits to the business, not just IT.

Although some people may think of observability as a buzzword for sophisticated application performance monitoring (APM), there are a few key distinctions to keep in mind when comparing observability and monitoring.

Monitoring vs. observability: What’s the difference between monitoring and observability?

Is observability really monitoring by another name? In short, no. While observability and monitoring are related—and can complement one another—they are actually different concepts.

Monitoring

In a monitoring scenario, you typically preconfigure dashboards to alert you about performance issues you expect to see later. However, these dashboards rely on the key assumption that you’re able to predict what kinds of problems you’ll encounter before they occur.

Cloud-native environments don’t lend themselves well to this type of monitoring because they are dynamic and complex, which means you cannot predict what problems might arise in advance.

Observability

In an observability scenario, where teams have fully instrumented an environment to provide complete observability data, you can flexibly explore what’s going on and quickly figure out the root cause of issues you may not have been able to anticipate.

Traditionally, the industry defines observability as logs, metrics, and traces. In more complex cloud environments, however, observability must encompass more, including metadata, user behavior, topology and network mapping, and access to code-level details.

Why is observability important?

In enterprise environments, observability helps cross-functional teams understand and answer specific questions about what’s happening in highly distributed systems. Observability enables you to understand what is slow or broken and what you need to do to improve performance. With an observability solution in place, teams can receive alerts about issues and proactively resolve them before they impact users.

Understanding “unknown unknowns”

Because modern cloud environments are dynamic and constantly changing in scale and complexity, teams neither know about nor can monitor most problems. Observability addresses this common issue of “unknown unknowns,” enabling you to continuously and automatically understand new types of problems as they arise.

Automating AIOps and DevSecOps

Observability is also a critical capability of artificial intelligence for IT operations (AIOps). As more organizations adopt cloud-native architectures, they are also looking for ways to implement AIOps, harnessing AI as a way to automate more processes throughout the DevSecOps lifecycle. By bringing AI to everything—from gathering telemetry to analyzing what’s happening across the full technology stack—your organization can have the reliable answers essential for automating application monitoring, testing, measuring service level objectives (SLOs), continuous delivery, application security, and incident response.

Optimizing user experiences

The value of observability doesn’t stop at IT use cases. Once you begin collecting and analyzing observability data, you have an invaluable window into the business impact of your digital services. This visibility enables you to optimize conversions, validate that software releases meet business goals, and prioritize business decisions based on what matters most.

When an observability solution also analyzes user experience data using synthetic and real-user monitoring, you can discover problems before your users do and design better user experiences based on real, immediate feedback.

Benefits of observability

Observability delivers powerful benefits to IT teams, organizations, and end users alike. Following are some of the use cases observability facilitates.

1 Application performance monitoring

Full end-to-end observability enables organizations to get to the bottom of application performance issues much faster, including issues that arise from cloud-native and microservices environments. Teams can also use an advanced observability solution to automate more processes, which increases efficiency and innovation among Ops and Apps teams.

2 DevSecOps and SRE

Observability is not just the result of implementing advanced tools but a foundational property of an application and its supporting infrastructure. The architects and developers who create the software must design it to be observed. Then DevSecOps and SRE teams can leverage and interpret the observable data during the software delivery lifecycle to build better, more secure, and more resilient applications.

3 Monitoring infrastructure, cloud, and Kubernetes environments

Infrastructure and operations (I&O) teams can leverage the enhanced context an observability solution offers for monitoring on-premises and cloud infrastructure and Kubernetes environments. This unified observability-based approach can improve application uptime and performance, cut down the time required to pinpoint and resolve issues, detect cloud latency issues, optimize cloud resource utilization, and improve administration of their Kubernetes environments and modern cloud architectures.

4 End-user experience

A good user experience can enhance a company’s reputation and increase revenue, delivering an enviable edge over the competition. By spotting and resolving issues well before the end-user notices and making an improvement before it’s even requested, an organization can boost customer satisfaction and retention. It’s also possible to optimize the user experience through real-time playback, gaining a window directly into the end-user’s experience exactly as they see it, so everyone can quickly agree on where to make improvements.

5 Business analytics

Business analytics enable organizations to combine business context with full stack application analytics and performance to understand real-time business impact, improve conversion optimization, ensure that software releases meet expected business goals, and confirm that the organization is adhering to internal and external SLAs.

6 DevOps and DevSecOps automation

DevSecOps teams can tap observability to get more insights into the apps they develop, and automate testing and CI/CD processes so they can release better quality code faster. This means organizations waste less time on war rooms and finger-pointing. Not only is this a benefit from a productivity standpoint, but it also strengthens the positive working relationships that are essential for effective collaboration.

These organizational improvements open the door to further innovation and digital transformation. And more importantly, the end-user ultimately benefits in the form of a high-quality user experience.

How do you make a system observable?

If you’ve read about observability, you likely know that collecting the measurements of logs, metrics, and distributed traces are the three key pillars to achieving success. However, observing raw telemetry from back-end applications alone does not provide the full picture of how your systems are behaving.

Neglecting the front-end perspective potentially skews or even misrepresents the full picture of how your applications and infrastructure are performing in the real world for real users. Extending the three-pillars approach, IT teams must augment telemetry collection with user-experience data to eliminate blind spots:

1. Logs: Logs are structured or unstructured text records of discreet events that occurred at a specific time.
2. Metrics: Metrics are the values represented as counts or measures that are often calculated or aggregated over a period of time. Metrics can originate from a variety of sources, including infrastructure, hosts, services, cloud platforms, and external sources.
3. Distributed tracing: Tracing follows the activity of a transaction or request as it flows through applications and shows how services connect, including code-level details.
4. User experience: User experience data extends traditional observability telemetry by adding the outside-in user perspective of a specific digital experience on an application, even in pre-production environments.

Why the three pillars of observability aren’t enough

Obviously, data collection is only the start. Simply having access to the right logs, metrics, and traces isn’t enough to gain true observability of your environment. Once you’re able to use that telemetry data to achieve the end goals of improving end-user experience and business outcomes, only then can you really say you’ve achieved the purpose of observability.

The importance of open source solutions

There are other observability capabilities organizations can use to observe their environments. Open source solutions, such as OpenTelemetry, provide a de facto standard for collecting telemetry data in cloud settings. These open source solutions enhance observability for cloud-native applications and make it easier for developers and operations teams to achieve a consistent understanding of application health across multiple environments.

The role of real-user monitoring (RUM) and synthetic testing

Organizations can also use real user monitoring to gain real-time visibility into the user experience, tracking the path of a single request and gaining insight into every interaction it has with every service along the way. Teams can observe this experience using synthetic monitoring or even view a recording of the actual session. These capabilities extend telemetry by adding in data for APIs, third-party services, errors occurring in the browser, user demographics, and application performance from the user’s perspective.

With real-user monitoring IT, DevSecOps, and SRE teams can not only see the complete end-to-end journey of a request but also access real-time insight into system health. From there, they can proactively troubleshoot areas of degrading health before they impact application performance. They can also more easily recover from failures and gain a more granular understanding of the user experience.

Don’t forget over-burdened teams

While IT organizations have the best of intentions and strategy, they often overestimate the ability of already overburdened teams to constantly observe, understand, and act upon an impossibly overwhelming amount of data and insights. Although there are many complex challenges associated with observability, the organizations that overcome these challenges will find it worth their while.

What are the challenges of observability?

Observability has always been a challenge, but cloud complexity and the rapid pace of change have made it an urgent issue. Cloud environments generate a far greater volume of telemetry data, particularly in microservices and containerized application environments. They also create a far greater variety of telemetry data than teams have ever had to interpret in the past. Lastly, the velocity with which all this data arrives makes it that much harder to keep up with the flow of information, let alone accurately interpret it in time to troubleshoot a performance issue.

Organizations also frequently run into the following challenges with observability.

1 Data silos

Multiple agents, disparate data sources, and siloed monitoring tools make it hard to understand interdependencies across applications, multiple clouds, and digital channels, such as web, mobile, and IoT.

2 Volume, velocity, variety, and complexity

It’s nearly impossible to get answers from the sheer amount of raw data collected from every component in ever-changing modern cloud environments, such as AWS, Azure, and Google Cloud Platform (GCP). This is also true for Kubernetes and containers that can spin up and down in seconds.

3 Manual instrumentation and configuration

When IT resources are forced to manually instrument and change code for every new type of component or agent, they spend most of their time trying to set up observability rather than innovating based on insights from observability data.

4 Lack of pre-production

Even with load testing in pre-production, developers still don’t have a way to observe or understand how real users will impact applications and infrastructure before they push code into production.

5 Wasting time troubleshooting

Application, operations, infrastructure, development, and digital experience teams are pulled in to troubleshoot and try to identify the root cause of problems, wasting valuable time guessing and trying to make sense of telemetry and come up with answers.

6 Multiple tools and vendors

While a single tool may give an organization observability of one specific area of their application architecture, that one tool may not provide complete observability across all the applications and systems that can affect application performance.

7 Inability to determine root-causes

Also, not all types of telemetry data is equally useful for determining the root cause of a problem or understanding its impact on the user experience. As a result, teams waste time digging for answers across multiple solutions and painstakingly interpreting the telemetry data when they could be applying their expertise toward fixing the problem right away.

However, with a single source of truth, teams can get answers and troubleshoot issues much faster.

The importance of a single source of truth

Organizations need a single source of truth to gain complete observability across their application infrastructure and accurately pinpoint the root causes of performance issues. When organizations have a single platform that can tame cloud complexity, capture all the relevant data, and analyze it with AI, teams can instantly identify the root cause of any problem, whether it lies in the application itself or the supporting architecture.

A single source of truth enables teams to do the following:

• Turn terabytes of telemetry data into real answers rather than asking IT teams to cobble together an understanding of what has happened using snippets of data from disparate sources
• Gain crucial contextual insights into areas of the infrastructure they might not have otherwise been able to see
• Work collaboratively and accelerate the troubleshooting process further, which empowers the organization to act faster than it could by using traditional monitoring tools thanks to enhanced awareness

Making observability actionable and scalable for IT teams

To achieve observability, resource-constrained teams need to be able to collect and act upon a deluge of telemetry data in real time. Responding in real time enables teams to prevent business-impacting issues from propagating further or even occurring in the first place. Following are some ways teams can make observability actionable and scalable.

1 Understand the context and the topology

Understanding the context and topology of an IT environment involves instrumenting applications and infrastructure in a way that identifies relationships between every entity and interdependency among potentially billions of interconnected components. Rich context metadata enables real-time topology maps, providing an understanding of causal dependencies both vertically throughout the stack and horizontally across services, processes, and hosts.

2 Implement continuous automation

Automatic discovery, instrumentation, and baselining of every system component on a continuous basis shifts IT effort away from manual configuration work to value-add innovation projects that can prioritize understanding of the things that matter. Observability becomes “always-on” and scalable, so constrained teams can do more with less.

3 Establish true AIOps

Exhaustive AI-driven fault-tree analysis combined with code-level visibility enables teams to automatically pinpoint the root cause of anomalies without having to rely on time-consuming human trial and error. Additionally, causation-based AI can automatically detect any unusual change points to discover “unknown unknowns” that teams are not aware of or monitoring. These actionable insights drive the faster and more accurate responses that DevOps and SRE teams require.

4 Foster an open ecosystem

An open ecosystem extends observability to include external data sources, such as OpenTelemetry, which is an open-source project led by vendors such as Dynatrace, Google, and Microsoft. OpenTelemetry expands telemetry collection and ingestion for platforms that provide topology mapping, automated discovery and instrumentation, and actionable answers required for observability at scale.

5 Utilize AI

An AI-driven solution-based approach makes observability truly actionable by solving the challenges associated with cloud complexity. An observability solution makes it easier to interpret the vast stream of telemetry data arising from multiple sources at increasingly greater velocities. With a single source of truth, teams can quickly and accurately pinpoint root causes of issues before they result in degraded application performance or, in the event a failure has already occurred, accelerate their time to recovery.

Advanced observability also improves application availability through end-to-end distributed tracing across serverless platforms, Kubernetes environments, microservices, and open-source solutions. By gaining visibility into the complete journey of a request from start to finish, teams can proactively identify application performance issues and gain crucial insight into the end-user experience. This way, IT teams can quickly act on issues of concern, even as the organization scales its application infrastructure to support future growth.

Bring observability to everything

You can’t waste months or years trying to build your own tools or test out multiple vendors that only enable you to solve one piece of the observability puzzle. Instead, you need a solution that can help make all your systems and applications observable, give you actionable answers, and provide technical and business value as fast as possible.

Advanced observability from Dynatrace provides all these capabilities in a single platform, empowering your organization to tame modern cloud complexity and transform faster. Now, more than ever, it’s critical to make comprehensive observability part of every cloud migration. At Dynatrace, we call that approach cloud done right.

The post What is observability? Not just logs, metrics and traces appeared first on Dynatrace news.

As an app developer, you have many recurring tasks, such as starting the development server, creating app functions, querying data stored in Grail, managing app configurations, and building and deploying apps. Sound familiar? The Visual Studio Code extension Dynatrace Apps is here to streamline your development process and simplify app building.

App configuration and build management

Let’s start with the basics: Use the App Configuration form (select Configure app in the VS Code Project tree) to set up all necessary options from the app manifest, including name, icon, version, and environment URL, as well as app scopes and content security policies. The extension wraps all important functionality from the Dynatrace App Toolkit to build and deploy your app, manage app dependencies, and test the new version of your app without redeployment.

Working with data

Dynatrace Apps are often used to “bring logic to data,” addressing new use cases on top of data stored in Dynatrace. Now you can easily query live data directly within VS Code using the Dynatrace Query Language (DQL).

First, create a new file, such as logQuery.dql, and enter your new query, utilizing autocompletion similar to Notebooks. The Run query button allows you to select a timeframe, executes the query directly from within the IDE, and shows the result in a new editor window. Then, you can explore the result’s data structure and access the JSON object’s properties.

(Re)Using queries within your app

Once you are happy with the result of your query, you can easily use it in your app code. Adding the annotation @name(“logsByLevel”) and saving the file auto-generates the corresponding TypeScript function runQueryLogsByLevel, ready for import and use within your app.

Dynamic queries

In real-world scenarios, most queries in the context of an app need some dynamic parameterization. This is achieved by adding another annotation. In the following example, we introduce a new parameter, logLevel, and define a default value ERROR by adding @param(“loglevel”, “ERROR”).

When saving the file, the generated function is automatically updated, and the new parameter can be used within the code.

Best practices when working with DQL

We recommend organizing multiple queries within a single file or across different DQL files to enhance the workspace structure. To seamlessly integrate query functions into React state management, utilize our react-hooks Dynatrace SDK package. This aids in effectively handling execution, loading, and error states.

The previously described process of generating a function for your query additionally produces a function named getQueryLogsByLevel, which returns the query along with the specified parameters. This feature proves particularly useful if you plan to implement an IntentButton. Such a button allows users to seamlessly open the query in another application, like Dynatrace Notebooks, for in-depth analysis and further exploration.

Working with app functions

App functions represent the backend, including all the business logic, of a Dynatrace app. They’re used for access to third-party APIs, heavy data processing and manipulation, or encapsulating functionality that needs elevated access rights.

You can create a new app function by selecting the Generate app function and entering a name. Once the function is generated, you can test the functionality by clicking the Play button next to the function name and reviewing the output in the console.

Now it’s your turn

Are you interested in learning more? Watch the latest video from Inside Dynatrace Apps, and see a live demo of the Dynatrace Apps VS Code extension.

If you want to start your own developer journey, head to the Microsoft Visual Studio Marketplace, download the extension, and benefit from increased developer efficiency thanks to simplified app configuration, effortless integration of DQL, and enhanced functionality through Dynatrace functions.

Are you new to the topic of developing apps for the Dynatrace platform? Head to our Developer Portal and learn how to get started by watching our new tutorial.

Happy coding!

The post Turbocharge Dynatrace app development with the new Visual Studio Code extension `Dynatrace Apps` appeared first on Dynatrace news.

An earlier blog post introduced how Akamas helps optimize Kubernetes clusters without “breaking the bank.” As one of the first Dynatrace partners, Akamas used its domain expertise and unique product capabilities to build a custom app on the Dynatrace platform. The app empowers platform engineering teams with insights into infrastructure health, FinOps, and security combined with alerting and automatic lifecycle management. In this way, the app reduces costs and improves the reliability and performance of all Kubernetes applications.

For example, the Akamas app optimized a Dynatrace-monitored Kubernetes environment, found 22 workloads with reliability issues and 53 workloads with sub-optimal performance, and identified potential savings of about $50,000 per month.

Insights into your Kubernetes environment

Leveraging Dynatrace observability data, Akamas analyzes all available Kubernetes workloads and identifies optimization opportunities such as cost reduction, reliability, and performance improvements.

As you can see in the screenshot below, you get a summary of all optimization opportunities identified in the environment. The table below lists all the individual Kubernetes workloads that can be optimized.

There is a cost reduction opportunity for the notification workload of $2,300 per month and other opportunities related to performance improvements and reliability issues due to misconfigured resource settings.

Optimize your workloads

Select Optimize next to the notification workload to open the Optimize workload page, which offers options for optimizing the workload. Akamas is a goal-driven optimization solution, which means you choose if you want to improve the application’s performance or lower the cost, which in Kubernetes translates to reducing the resource requirements of your containers for CPU, memory requests, and memory limits.

When you manually reduce your container’s resources to save costs, you risk impacting service performance and reliability. To avoid slowing down your apps or—even worse—harming SLOs, you can define constraints that need to be considered, such as response time or error rate. Once constraints are set, Akamas AI considers application-level performance signals so cost-reduction recommendations don’t impact your SLOs.

Before you can start optimizing, you need to define the scope. When you choose Container, Akamas tunes the Kubernetes CPU and memory limits. It also supports full stack optimization, which optimizes JVM parameters such as maximum heap size and garbage collection.

Stay in control: Monitor the optimization process

Returning to the overview, you can switch to the Optimizations tab, which summarizes all your running optimizations, including the optimization created in the previous step.

Select See details for any service to dive into more details about running optimization tasks. Besides showing a short summary, including optimization goals, constraints, and scope, you can dive into cost trends and the relevant SLOs.

In this example, despite the cost going down (from over $80 down to about $50), the application performance was not impacted and stayed well below the defined threshold of 340 milliseconds.

Apply configurations

Akamas can apply configurations automatically or suggest configurations that SRE teams can use for further manual improvements. In the example below, you can see the current CPU and memory limits and the new values suggested by Akamas: change the server.cpu_limit from 1,000 down to 982 millicores and reduce the server.memory_limit by 53 MB. Select the button in the top-right of the Pending Recommendation pane to reveal the kubectl command, which you can use to apply the suggested recommendations.

Summary

The Akamas app helps achieve three critical goals by optimizing Kubernetes application configurations, harnessing the power of artificial intelligence of the Akamas platform, and leveraging the capabilities of the Dynatrace platform:

• Cost reduction: Identify opportunities to trim unnecessary expenses related to Kubernetes workloads. Imagine saving thousands of dollars each month by fine-tuning your resource allocations.
• Reliability enhancement: Pinpoint reliability issues within your Kubernetes environment and ensure your applications run smoothly, minimizing downtime and improving overall system stability.
• Performance optimization: Fine-tune your software stack configurations to maximize performance parameters, ensuring applications meet or exceed their service level objectives (SLOs).

This is a perfect example of how to easily build custom apps on top of observability data stored within Dynatrace and leverage its enterprise-grade platform. Utilize the power of the Dynatrace platform, with its easy-to-use building blocks, to address specific use cases based on your business requirements.

Interested in learning more?

Watch the recording of one of this year’s Perform breakout sessions, where Stefano Doni, CTO and Co-founder of Akamas, and Alois Mayr, Principal Product Manager at Dynatrace, gave a quick intro to how Dynatrace and Akamas work better together, introducing the new Dynatrace Kubernetes monitoring app and how Akamas helps optimize your Kubernetes environment.

Start building your own Dynatrace app to address the specific needs of your users:

• Familiarize yourself with the possibilities for extending Dynatrace.
• Watch a recording and learn how to build your own Dynatrace app in less than 10 minutes.
• Head over to Dynatrace Developer and learn about the tools and technologies of Dynatrace AppEngine.

Are you interested in learning more about Akamas and why Dynatrace and Akamas are better together? Have a look at the Dynatrace Hub, watch a video tour, or contact Akamas directly to book a demo and get more insights into how Akamas can optimize your Kubernetes environment.

The post Dynatrace® Apps showcase: Akamas Kubernetes optimization appeared first on Dynatrace news.

As organizations look to expand DevOps maturity, improve operational efficiency, and increase developer velocity, they are embracing platform engineering as a key driver. Indeed, recent research found that 54% of organizations are investing in platforms to enable easier integration of tools and collaboration between teams involved in automation projects.

Platform engineering creates and manages a shared infrastructure and set of tools, such as internal developer platforms (IDPs), to enable software developers to build, deploy, and operate applications more efficiently. The goal is to abstract away the underlying infrastructure’s complexities while providing a streamlined and standardized environment for development teams. As a result, teams can focus on writing code and building features, rather than dealing with infrastructure nuances.

During a breakout session at Dynatrace Perform 2024, Dynatrace DevSecOps activist Andreas Grabner and staff engineer Adam Gardner demonstrated how to use observability to monitor an IDP for key performance indicators (KPIs). The pair showed how to track factors, including developer velocity, platform adoption, DevOps research and assessment metrics, security, and operational costs.

Recent Dynatrace research has found that only 40% of a typical engineer’s time is spent on productive tasks, and 36% of developers resign because of a bad developer experience, Grabner noted. “If your developers are leaving the company, the IDP may have something to do with it,” he said.

Platform engineering: Build for self-service

Self-service deployment is a key attribute of platform engineering. It gives developers the means to create environments and toolsets unique to their projects.

“[An IDP] must be a product that developers want to use because it helps them get the job done,” Grabner said. “It makes them more productive . . . and reduces the complexity of things such as reading a new app or service. They shouldn’t worry about the platform; they should just start writing code.”

Because of their versatility, teams can use IDPs for all types of software engineering projects, not just those in cloud-native scenarios. IDPs can eliminate much of the administrative minutiae that stalls development projects. Grabner gave the example of one Dynatrace banking customer who built an IDP that enables developers to provision new Microsoft Azure machines or Chef policies without administrative help. “IDPs are not constrained to building microservices or a new serverless app,” Grabner noted.

Before putting an IDP in place, organizations must encourage their platform engineering teams to adopt a product mindset with feedback loops between developers and users. They should also establish milestones to ensure the built product solves a defined business problem.

The Dynatrace IDP encompasses platform services, delivery services, and access to observability and automation tools. The Dynatrace Operator automatically ingests all observability data from OpenTelemetry and Prometheus. Furthermore, OneAgent® software observes and gathers all remaining workload logs, metrics, traces, and events.

Automate deployment for faster developer velocity

Additionally, the IDP used during the session connects to the open source Backstage developer portal platform and a library of templates stored in a GitLab repository. The templates can deploy automatically into the development environment with just a few clicks.

Argo works in a GitOps fashion to automate the deployment of files stored in Git. “Argo has an eagle eye on the Git repository,” Gardner said. “Every time something changes, it’s synced to Kubernetes.”

Backstage holds many of an organization’s critical development resources that must be treated with the same respect as business-critical data. Observability is not only about measuring performance and speed but also about capturing granular business analytics to support data-driven decision-making. These metrics can include how many people are using the IDP, how quickly the tasks are running in the IDP, and more. “That means making it available, resilient, and secure,” Grabner said.

Intelligent monitoring is also crucial. “If you don’t monitor, you risk building a product that nobody needs,” Grabner continued.

Observability is a critical component of an IDP. It illuminates the activity of components such as Backstage, GitHub, Argo, and other tools. Service-level objectives (SLOs) are similarly important. SLOs help developers to accelerate their velocity and remain productive with an optimally functioning platform.

Test continuously

Synthetic testing simulates user behaviors within an application or service to pinpoint potential problems. This process is vital to an IDP’s effectiveness. An observability solution can monitor both synthetic and real-user tests to verify an application is on track.

GitLab, a source code repository and collaborative software development platform for DevOps and DevSecOps projects, is populated with a set of pre-filled templates. The combination gives developers a unique set of tools they can deploy on a self-service basis with full monitoring by Dynatrace.

“Every time [developers] pick a template in Backstage, they get their own version of the Git repository based on the template. Then, Argo deploys the app,” Grabner said. “It has worked kind of flawlessly.”

Observability at the core

Platform engineering is about being responsible for making sure platforms are available,” Gardner said. “Dynatrace can tell us whether Argo is up and whether it’s killing GitHub with too many syncs. It lets us see events such as starts and traces in a standardized manner.” This certainty can accelerate developer velocity and improve the developer experience, resulting in better software and happier, more productive developers.

Dynatrace has made the reference IDP architecture available on GitHub for anyone to use. It includes a notebook with configuration and deployment instructions.

“It explains every single step that was involved in building the IDP, creating the configuration, and setting up Argo,” Gardner said. “You can launch a code space that starts a container that shows you everything about how an app was built and deployed.”

FAQs about platform engineering

What is the primary role of an internal developer platform (IDP)?

An IDP is a shared infrastructure and set of tools created and managed by platform engineering teams. By providing a self-service, standardized environment, IDPs enable software developers to more efficiently build, deploy, and operate applications. IDPs reduce the need for developers to manage underlying infrastructure nuances, thereby simplifying workflows and accelerating application delivery.

How does platform engineering improve software development?

Platform engineering accelerates developer velocity by providing a streamlined, standardized environment that abstracts away infrastructure complexities. This allows developers to focus on writing code and building features more efficiently.

It improves the developer experience by offering self-service tools and automating tasks, reducing the cognitive load and administrative minutiae that can otherwise hinder productivity and frustrate developers.

Why is observability crucial for successful platform engineering?

Observability is crucial for successful platform engineering because it provides deep insights into the performance, health, and activity of the internal developer platform and its components. It allows platform teams to monitor key performance indicators (KPIs) like platform adoption and operational costs, helping to support the platform’s availability, resiliency, and security. Continuous monitoring helps verify the effectiveness of the IDP and ensures developers maintain optimal productivity.

What are the key principles for building an effective internal developer platform?

Building an effective internal developer platform involves adopting a product mindset, treating developers as internal customers, and incorporating their feedback through continuous loops. Here are some principles to keep in mind as you build:

• Provide clear self-service capabilities.
• Automate repetitive tasks.
• Focus on solving common developer pain points.

The platform should also emphasize scalability, security, and compliance, while fostering a culture of collaboration and knowledge sharing within the engineering organization.

The post How platform engineering and IDP observability can accelerate developer velocity appeared first on Dynatrace news.

Through containers developed within VA Platform One (VAPO), the development team at the U.S. Department of Veterans Affairs (VA) is packaging application code along with its libraries and dependencies within an executable software unit. The containers can run anywhere, whether a private data center, the public cloud or a developer’s own computing devices. Dynatrace container monitoring supports customers as they collect metrics, traces, logs, and other observability-enabled data to improve the health and performance of containerized applications.

At Perform 2024, Matthew Fuqua, Technical Lead for VAPuO, sat down with Willie Hicks, Dynatrace Public Sector Chief Technologist, to discuss his team’s role in VA’s modernization journey—and how Dynatrace has significantly accelerated its progress while unleashing new capabilities.

What is VAPO?

VA Platform One (VAPO) is a comprehensive application development and delivery platform. The VAPO platform is used to develop, test, and deploy containerized application and middleware workloads that support 400,000 VA employees and 20 million veterans. VAPO relies on Dynatrace and its integration with Red Hat to monitor application development and testing within containers to ensure optimal performance and security.

“It’s an enterprise product that we use to help modernize the VA,” Fuqua said. “It’s one of our biggest modernization efforts, and it’s saving us money while providing better, quicker, and faster healthcare to our veterans.”

VAPO is available in both Microsoft Azure and AWS. It’s supported by the VA Enterprise Cloud (VAEC), a multi-vendor, FedRAMP High environment for hosting VA applications in the cloud.

VA Platform One enables rapid application development with “security first” oversight

VA Platform One provides developers with all the tools required to create, test, and push out applications swiftly. With VA’s heavy focus on security, the platform enables developers to incorporate security testing for applications during development. “In the development environment, you see exactly where in the pipeline security issues exist, and you can address them right there, so it speeds up development,” Fuqua said. “It’s easy to produce a container that we can rapidly test, then shift to pre-production and production. It’s helping us build applications more efficiently and faster and get them in front of veterans.”

Supporting application modernization with a focus on user experience (UX)

While VA is developing new applications, they also have monolithic applications to modernize. That modernization effort starts with Dynatrace. “We can look at user experiences and CPU memory usage over time,” Fuqua said. “Then, we can show our results once we containerize: what we’re saving, if the user experience is better or worse and, if not, we can improve that. We use Dynatrace as part of our migration pattern, so we can see how well we’re doing our jobs.”

With Dynatrace, Fuqua’s team has full observability of the applications themselves in a dashboard, so his team can make sure users are getting all they need. “We can log into an actual experience and it captures everything,” he said.

AI and automation simplify container monitoring and satisfy the “need for speed”

Container monitoring is inherently challenging because of containers’ highly dynamic nature. Dynatrace artificial intelligence (AI)-powered root cause analysis brings real-time insights and actionable answers to fix issues, automating operations so the VAPO team can focus on innovation. “We want to get to a point where we can identify something, then the platform automatically creates a ticket that goes to an approver,” Fuqua said. “If the approver says, ‘do it,’ then it schedules the action.”

With a consistent focus on UX, VA is leveraging synthetic monitoring to gain an accurate view of UX and then using automation to scale containers ahead of demand. “We’re using automation to kick off scaling events,” he said. “We want to be there in time.”

The veteran is the mission

As Hicks summarized, VA’s mission is focused on the veteran. “Your most important end user is the veteran,” he said.

The VAPO team appreciates how Dynatrace puts everything “all in one place” while making it so much easier to solve problems. “This is a continuous process,” Fuqua said. “You’re not going to wave a magic wand and have a container. With Dynatrace, we’re getting in there and doing things in phases and continuously improving.”

The post Container monitoring for VA Platform One helps VA achieve workload performance appeared first on Dynatrace news.

In today’s complex digital landscape, organizations need to be able to scale and innovate in order to compete. The collaborative partner innovation showcased between Dynatrace and its strategic partnerships is a critical piece of enabling growth for our customers.

While the curtains have fallen on Perform 2024, the Dynatrace annual user conference, the commitment and collaborative nature of our partner relationships is consistently being demonstrated. During the conference, we unveiled the winners of the Dynatrace Partner Pro Club app competition. This challenge invited our partners to create impactful apps that solve real-world customer use cases using Dynatrace AppEngine. Below are the winners.

Elevating user experience and design with collaborative partner innovation

The top submissions stood out by solving complex business challenges and focusing on creating an exceptional user experience. The winning User Flow Analytics app by Andrea Caria of Spindox introduces a visual analysis of user navigation within web, mobile, or custom applications, presented through dynamic Sankey diagrams and funnels. This innovative approach enhances the understanding of user journeys through compelling visuals, setting the standard for future app developments.

The User Flow Analytics app was created to address real-life business challenges. For example, a multinational manufacturing company wanted to improve the performance and user experience of their mobile apps and websites. They asked Spindox to evaluate their existing product analytics software and suggest potential alternatives. After careful consideration, Spindox recommended the Dynatrace unified observability and security platform. Spindox also realized that if they could extend the Dynatrace Platform to cover user-funnel analytics and user-navigation Sankey diagrams, it would help the customer consolidate their tooling. Using Dynatrace AppEngine, Spindox was able to implement funnel analytics according to the customer’s specifications, providing them with all the information they needed within a single platform.

“AppEngine is a stunning step forward in data monitoring because it allows you to merge the customization of coding with the high-quality data stored in Dynatrace, unlocking the limits of analysis beyond imagination. The more time you spend developing your application, the more you understand its potential by assembling the amazing number of ready-made components that Dynatrace provides.” — Andrea Caria, observability solution analyst at Spindox. 

Recognizing the runners up

While there was an overwhelming amount of quality submissions, we have to recognize two outstanding runners-up. Gil Givati’s (Matrix) HALO app impressed by allowing users to visually create holistic objectives for applications or products. Meanwhile, Michiel Otten’s (Eviden) Cross Platform Insights app garnered applause for providing a unified view of health across multiple Dynatrace environments.

“We were truly impressed by the apps showcased in the Dynatrace Pro Club app competition. Our partners combined their technical prowess and industry insight to engineer apps that effectively utilize observability, security, and business data to solve key customer challenges. I’m excited about the prospects of AppEngine empowering the creation of numerous groundbreaking custom apps.” — Ahmed El-Jafoufi, global partner enablement architect at Dynatrace.

A collective leap forward

AppEngine empowers partners to create custom solutions that are secure and enterprise-grade with the familiar Dynatrace out-of-the-box look and feel.

Our competition wasn’t just about winning; it was about pushing the boundaries of what’s possible in observability and security. The submissions we received were a testament to the power of innovative partner collaboration, and the shared commitment of Dynatrace and its partners to lead the way in shaping the future of digital experiences.

All of this year’s participants contributed to making this competition a success. The dedication of our partners to excellence elevates the Dynatrace ecosystem and continues to set the standard for what’s possible in the dynamic world of unified observability and security.

Dynatrace Partner Pro Club

Partner Pro Club is an initiative to recognize and reward Dynatrace partners who invest the time and commitment to achieving their Dynatrace Professional certification. Members gain access to exclusive events and training, fostering a community of champions.

• Learn more about what AppEngine can do for you.
• Join the Partner Pro Club by becoming Dynatrace Professional Certified now.
• Specialize in developing custom apps and become App Developer Certified.

The post Unlocking collaborative partner innovation: 2023 Dynatrace Partner Pro Club winners appeared first on Dynatrace news.

Developers are increasingly responsible for ensuring the quality and security of code throughout the software lifecycle. Traditional tools and approaches, however, only allow debugging in pre-production environments. Debugging in production often requires shutting down services. This can disrupt the users of the running application, slow down the application’s performance, or even crash it altogether.

Developer-first observability

Adding Rookout to the Dynatrace platform will provide developers with increased code-level observability of Kubernetes-hosted production environments. This will also add interactivity and control to troubleshooting and debugging in production, drastically reduce the need to replicate issues in pre-production environments and improve collaboration across development, IT, and security teams.

As Shahar Fogel, CEO at Rookout, said, “Our mission is to make debugging easy and fast for developers with state-of-the-art quality and a simple experience. We believe integrating Rookout into the Dynatrace platform and leveraging the artificial intelligence and automation capabilities Dynatrace is known for will accelerate this mission. This will also create a new standard for how engineers use developer-first, cloud-native observability to improve productivity by enabling them to spend less time on manual activities and more time delivering business value.”

Observability and security continue to converge

“Development teams are increasingly expected to incorporate observability and security capabilities into their solutions (shift-left) as well as perform testing, quality, and performance evaluation in production environments (shift right),” said Bernd Greifeneder, CTO at Dynatrace. “We believe acquiring Rookout will accelerate this process by providing our customers with developer-observability solutions that scale from a developer’s integrated development environment, or IDE, and are designed to enable their organizations to meet enterprise governance requirements. Our experience is that Rookout enables developers to troubleshoot and debug issues in production significantly faster than traditional tools and approaches, dramatically reducing the time they spend on maintenance activities.”

Closing of the proposed transaction is subject to customary closing conditions and is expected to occur later in the company’s second quarter, which ends on September 30, 2023. The proposed transaction will not have a material impact on Dynatrace’s fiscal year 2024 financials and will be funded from cash on hand.

The post Dynatrace to acquire Rookout to deliver code debugging in production environments appeared first on Dynatrace news.

Developers are increasingly responsible for ensuring the quality and security of code throughout the lifecycle. Traditional tools and approaches, however, only allow debugging in pre-production environments. Debugging in production often requires shutting down services. This can disrupt the users of the running application, slow down the application’s performance, or even crash it altogether.

Adding Rookout to the Dynatrace platform will provide developers with increased code-level observability into production environments. This will also add interactivity and control to troubleshooting and debugging in production and drastically reduce the need to replicate issues in pre-production environments. The addition of Rookout to the Dynatrace platform will also improve collaboration across development, IT, and security teams by empowering them with a single platform for observability and security analytics and automation.

“Development teams are increasingly expected to incorporate observability and security capabilities into their solutions (shift-left) as well as perform testing, quality, and performance evaluation in production environments (shift-right),” said Bernd Greifeneder, CTO at Dynatrace. “We believe acquiring Rookout will accelerate this process by providing our customers with developer-observability solutions that scale from a developer’s integrated development environment, or IDE, and are designed to enable their organizations to meet enterprise governance requirements. Our experience is that Rookout enables developers to troubleshoot and debug issues in production significantly faster than traditional tools and approaches, dramatically reducing the time they spend on maintenance activities.”

“Our mission is to make debugging easy and fast for developers with state-of-the-art quality and a simple experience,” said Shahar Fogel, CEO at Rookout. “We believe integrating Rookout into the Dynatrace platform and leveraging the AI and automation capabilities Dynatrace is known for will accelerate this mission. This will also create a new standard for how engineers use developer-first, cloud-native observability to improve productivity by enabling them to spend less time on manual activities and more time delivering business value.”

Dynatrace plans to provide a seamless experience for customers by embedding Rookout into its unified observability and security platform.

Closing of the proposed transaction is subject to customary closing conditions and is expected to occur later in the company’s second quarter, which ends on September 30, 2023. The proposed transaction will not have a material impact on Dynatrace’s fiscal year 2024 financials and will be funded from cash on hand.

Cautionary Language Concerning Forward-Looking Statements

This press release includes certain “forward-looking statements” within the meaning of the Private Securities Litigation Reform Act of 1995, including statements regarding the anticipated benefits of the Rookout acquisition, the expected time for closing of the proposed acquisition, the impact of the proposed acquisition on Dynatrace’s fiscal year 2024 financials, and the source of funding of the transaction. These forward-looking statements include all statements that are not historical facts and statements identified by words such as “will,” “expects,” “anticipates,” “intends,” “plans,” “believes,” “seeks,” “estimates” and words of similar meaning. These forward-looking statements reflect our current views about our plans, intentions, expectations, strategies, and prospects, which are based on the information currently available to us and on assumptions we have made. Actual results may differ materially from those described in the forward-looking statements and will be affected by a variety of risks and factors that are beyond our control, including risks set forth under the caption “Risk Factors” in our Annual Report on Form 10-K for the fiscal year ended March 31, 2023 and our other SEC filings. We assume no obligation to update any forward-looking statements contained in this document as a result of new information, future events or otherwise.

The post Dynatrace to Acquire Rookout to Deliver Code Debugging in Production Environments appeared first on Dynatrace news.

For cities, counties, and states that use geographic information system (GIS) apps such as ArcGIS to drive mission critical services, application resilience is essential. With so much at risk during an emergency, ensuring performance apps don’t lag or crash when they’re most needed is vital.

Advanced observability can eliminate blind spots surrounding application performance, health, and behavior for these critical applications and the infrastructure that supports them. Suppose ArcGIS has an unexpected outage. Usually, IT teams scramble with time-consuming and expensive fire drills to find and repair the root cause. Envision if IT teams could be proactively alerted before the field teams discover they can’t complete their gas line maintenance work or load the maps required to fix the freshwater infrastructure in the county. Alerts that deliver actionable data, such as ranking issues and pinpointing the root cause, enable teams to prioritize their efforts on the issues with the most significant user impact and accelerate the resolution.

When considering the financial costs of each hour of downtime, observability delivers a compelling return on investment (ROI). It empowers the team to recover faster as well as proactively prevent outages from happening in the first place.

Gaining a complete picture of app health in hybrid environments

As a starting point, teams should know if ArcGIS and other critical apps are available. While uptime is essential, availability doesn’t ensure optimal performance. This is why application performance monitoring (APM) is essential.

The challenge is that state and local governments operate in highly complex systems — legacy data centers or hybrid environments — crossing multiple clouds. That’s why it’s difficult to understand the root cause of performance anomalies. IT teams need full situational awareness of all assets and an understanding of how they’re performing, including third party vendor apps that were not built in-house.

Agency leaders have just as much to gain from adopting observability solutions as those on the front lines of DevSecOps efforts. Adopting APM can enable staff to improve citizen experience and by extension, agency reputation. Further, APM can improve employee satisfaction by eliminating the manual work of scrubbing every log to correlate events to discover what’s causing a problem with mission-critical software such as ArcGIS.

Understand user interactions with critical GIS software

While it’s important to have an application performance strategy, a top mission for state and local governments is to enhance the citizen experience. An advanced observability strategy includes end user experience monitoring to evaluate digital experiences—such as a website or mobile application—from the user’s perspective.

For example, Real User Monitoring (RUM) can provide an accurate picture of employee or citizen experience with an app. User Session Replay enables IT to resolve customer complaints by watching visual replays to determine exactly what went wrong during a session.

With these tools, agency leaders can empower IT teams to understand how citizens are using digital touchpoints, the obstacles they encounter as they’re using them, and how to eliminate those points of friction, whether in the app, database, or the infrastructure that hosts them.

Automatically discover how infrastructure and database changes impact critical app performance

Full-stack observability gives complete, real-time insight into applications’ behavior, health, the underlying infrastructure, and all other services on which the applications might depend.

Infrastructure monitoring automatically analyzes key health metrics and discovers performance problems caused by infrastructure bottlenecks or changes. As a result, IT teams can proactively identify and resolve potential infrastructure issues with ArcGIS and other critical applications before they impact performance and the citizen experience.

Similarly, observability provides detailed telemetry about the database performance that applications like ArcGIS depend on, including the health of the underlying infrastructure, the state of the database instance, and deep-dive analysis of each database statement and its performance.

Agency leaders can cut costs and improve productivity by eliminating the monitoring tool sprawl that pushes teams to work in silos. With a single source of truth for root cause analysis, IT and DevOps teams can quickly get on the same page about what needs to be done and who’s responsible for it.

Automate vulnerability detection for apps in the IT environment

With growing ransomware attacks, state and local governments must ensure applications don’t contain vulnerabilities that could allow illicit access to sensitive data, unauthorized code modification, or resource hijacking. Ensuring secure applications amid rising complexity is crucial to the digital transformation journey.

Further, applications aren’t as simple as they used to be, and ensuring they’re secure has become more challenging. Whether built in-house or purchased, any application can introduce vulnerabilities into the environment. However, it is more challenging to discover and remediate vulnerabilities when you don’t own the application code.

Full-stack runtime vulnerability analysis provides a holistic view and analysis across all layers of the application ecosystem, so teams have a single source of truth to provide the answers they need. Imagine the team discovers a vulnerability within a third-party app. They can immediately alert the vendor and hold them accountable for the fix to secure your environment. This approach helps agencies eliminate security blind spots and validate that vendors meet the agreed-upon service level agreements.

Ensure IT teams have actionable and scalable data to support the agency and its mission

The challenges agencies face in accelerating digital transformation are obvious, but meaningful answers are hard to come by. Purpose-built monitoring software often becomes shelfware because it’s too difficult to deploy, configure, or understand.

When building the technology stack, agencies must think in the context of the citizen and employee experience. ArcGIS software enables state and local agencies to enhance community service offerings, provide transparency, and engage citizens. Modern observability ensures that IT teams have the tools to appropriately manage and optimize critical application resilience, including ArcGIS performance.

A full stack observability solution enables staff to see it all, top to bottom, from end-user experience to infrastructure health. It also helps teams understand how everything is connected — including all the relationships and interdependencies among layers, components, or pieces of code. These capabilities can help your agency digitally transform faster and more easily — even as cloud complexity increases to ensure that the agency can provide the best possible services to citizens and the right tools to improve employee satisfaction.

The post Critical app observability in government including ArcGIS appeared first on Dynatrace news.

If you’re evaluating container orchestration software to manage containerized applications at scale, you may be wondering about the differences between OpenShift and Kubernetes. But as you contemplate OpenShift vs. Kubernetes, it’s important to understand what these container orchestration solutions are, how they relate, and their benefits and drawbacks.

A guide to container orchestration software

Container orchestration software automates the administration of containerized workloads and services, greatly reducing the time IT staff spend keeping an application environment running smoothly. Container orchestration allows an organization to digitally transform at a rapid clip without getting bogged down by slow, siloed development, difficult scaling, and high costs associated with optimizing application infrastructure.

As with Kubernetes vs. Docker, OpenShift vs. Kubernetes is a common debate, as they are two of the most widely used container orchestration tools. Although they share many features in common, there are also critical differences between OpenShift and Kubernetes. To put those differences into perspective, let’s look at what Kubernetes and OpenShift are and how they work.

What is Kubernetes?

Kubernetes is an open source container orchestration platform that enables organizations to automatically scale, manage, and deploy containerized applications in distributed environments. According to the Kubernetes in the Wild 2023 report, “Kubernetes is emerging as the operating system of the cloud.” In recent years, cloud service providers such as Amazon Web Services, Microsoft Azure, IBM, and Google began offering Kubernetes as part of their managed services. As a result of these services, organizations can further streamline the administrative overhead associated with application development.

Kubernetes containers are portable across environments, which enables developers to run them on nearly any type of infrastructure, whether in the cloud or locally. This flexibility helps organizations avoid vendor lock-in. Kubernetes also gives developers freedom of choice when selecting operating systems, container runtimes, storage engines, and other key elements for their Kubernetes environments. They can integrate their own applications in the Kubernetes API or use Kubernetes’ own tooling to roll out new features. One major Kubernetes advantage is its self-healing, continually making repairs and addressing failures that affect applications’ integrity.

That said, Kubernetes has some drawbacks. Its inherent complexity makes observability difficult — especially when used across highly distributed systems. IT teams can’t see into the internal state of Kubernetes containers, so they often collect a wide variety of telemetry data — such as logs, metrics, and distributed traces — to compensate for this lack of visibility.

While these data sources are helpful, they often can’t help IT understand the relationships and context necessary to quickly identify the root causes of application performance issues. As a result, organizations can have trouble transforming at scale, improving critical service-level agreements, and optimizing the user experience.

What is OpenShift?

Like Kubernetes, OpenShift is an open source Kubernetes-based container platform. OpenShift is developed by Red Hat and can run in a variety of environments — both cloud and on premises. In fact, it is a frequent choice for running Kubernetes on premises.

Because it’s based on Kubernetes, OpenShift provides containerization and orchestration of containerized workloads. Like Kubernetes, it allocates resources efficiently and ensures high availability and fault tolerance.

But OpenShift builds from there to provide integrated development tools, CI/CD (continuous integration/continuous deployment) pipelines, and built-in support for popular programming languages, frameworks, and databases. These tools enable OpenShift to support the entire application lifecycle, from development to production, including scaling, rolling updates, and version control. Without having to worry about underlying infrastructure concerns, such as storage, security, and lifecycle management, developers can focus on writing code.

Likewise, Red Hat OpenShift helps organizations administer Kubernetes more efficiently. For example, OpenShift simplifies Kubernetes management tools, giving developers everything they need to manage Kubernetes nodes, as well as the underlying control plane.

In addition, OpenShift provides numerous cloud services and self-managed deployment models to suit various applications and architectures, including the following:

• OpenShift Container Platform (OCP). This self-managed offering can run on premises or in the cloud.
• OpenShift Dedicated (OSD). The managed service runs on public clouds such as Amazon Web Services and Google Cloud.
• Red Hat OpenShift Online (OSO). This fully managed service runs on Red Hat’s public cloud.

Despite its advantages, however, OpenShift also has its limitations. While Kubernetes supports all cloud and Linux distributions, making it widely accessible to organizations using various platforms, OpenShift supports only Red Hat distributions, such as Red Hat Enterprise Linux (RHEL), CentOS, and Fedora. As a commercial solution, OpenShift is also comparatively less flexible than open source Kubernetes, making it less customizable to an organization’s unique requirements.

OpenShift vs. Kubernetes: Weighing the key differences

While Kubernetes and OpenShift are both popular container orchestration platforms, they are used in slightly different ways and offer different features. Some of the key differences include the following:

• Origin. Originally created by Google, Kubernetes is an open source project managed by the Cloud Native Computing Foundation (CNCF). OpenShift, on the other hand, is an open source Red Hat offering that is built on top of Kubernetes primarily on RHEL operating systems.
• Ease of use. While Kubernetes offers increased flexibility and powerful features, it can be complex to set up and manage. In contrast, OpenShift provides a simplified, user-friendly interface, with built-in support for CI/CD pipelines.
• Security. OpenShift has several built-in security features, while Kubernetes relies on the underlying infrastructure and additional tools for security. Additionally, OpenShift runs containers as a non-root user by default and provides additional security policies out of the box.
• Networking. Kubernetes provides a basic networking model. However, it needs additional tools or plugins for more advanced networking features. OpenShift, on the other hand, includes a more advanced software-defined networking (SDN) solution, which supports network policies for finer control over container communication.
• Updates and support. Kubernetes has frequent updates, which can sometimes lead to issues such as breaking changes. Red Hat OpenShift offers long-term support versions and commercial support.
• Integration and extensions. Kubernetes is more of a bare-bones platform. Therefore, it relies on external tools and services for most integrations and extensions. Conversely, as a Red Hat offering, OpenShift provides built-in integration with other Red Hat products and offers a marketplace for third-party extensions.
• Pricing. Unlike Kubernetes, which is a completely free and open source service, OpenShift has a pricing model for its enterprise version that includes additional features, support, and services.

A lesson in terminology: Kubernetes namespace vs. OpenShift project

It’s OpenShift vs. Kubernetes when it comes to terminology, too. In addition to the aforementioned feature differences, Kubernetes and OpenShift use different terminology, which can be confusing for organizations and practitioners alike.

For example, a namespace in Kubernetes is typically referred to as a project in OpenShift. Despite their similarities, there are a few differences between namespaces and projects, including the following:

• Access control. In Kubernetes, users manage access control independently from namespaces. In contrast, OpenShift’s projects have a predefined set of permissions for project-level operations. This makes it easier for organizations to control who has access to what within a project.
• Isolation. While teams use both namespaces and projects to isolate resources within a cluster, OpenShift’s projects provide additional features. These include the ability to limit the amount of resources that all containers can consume within a project.
• User-friendly. Unlike Kubernetes namespaces, OpenShift projects are more user-friendly. When a user creates a project, for instance, they automatically become the project admin. With Kubernetes namespaces, this does not happen automatically.

Which container orchestration software is right for you?

If your organization needs a container orchestration solution with enterprise-level support and security, OpenShift is the clear choice. OpenShift offers a secure-by-default option to increase security, and its security policies are much stricter than Kubernetes. OpenShift is also a good choice if CI/CD is a priority for your organization.

Additionally, OpenShift is designed to meet the needs of industries with strong compliance and regulatory requirements, such as healthcare or finance. It addresses regulations such as the European Union’s General Data Protection Regulation and the U.S. Health Insurance Portability and Accountability Act.

On the other hand, Kubernetes is a strong option if you need more customization and flexibility, and you have in-house Kubernetes experts who can troubleshoot problems as they arise.

Kubernetes also works on the widest possible range of operating systems and platforms. If you’re a social media or gaming company that places an especially high priority on releasing updates at a rapid pace, Kubernetes may be a better fit.

Automatic and intelligent observability for OpenShift and Kubernetes

Whether you choose OpenShift vs. Kubernetes or vice versa, Dynatrace can make the most of your container orchestration solution. Dynatrace uses AIOps and cloud observability to combine metrics, logs, and traces with topology information, real user experience data, and meta information. With advanced observability of every Kubernetes cluster, pod, and node — and all connections and dependencies they touch — you can quickly pinpoint and solve performance problems as they arise.

Additionally, Dynatrace offers powerful monitoring capabilities for OpenShift, helping you manage costs, automate your operations, and release better software faster.

Whether using OpenShift or Kubernetes, the Dynatrace observability and security platform is the only Kubernetes monitoring system with continuous automation that identifies and prioritizes alerts from applications and infrastructure without changing code, container images, or deployments.

The post OpenShift vs. Kubernetes: Understanding the differences appeared first on Dynatrace news.

Kubernetes has become the leading container orchestration platform for organizations adopting open source solutions to manage, scale, and automate application deployment. Adopting this powerful tool can provide strategic technological benefits to organizations — specifically DevOps teams. At the same time, it also introduces a large amount of complexity. This complexity has surfaced seven top Kubernetes challenges that strain engineering teams and ultimately slow the pace of innovation.

What is Kubernetes? And how does it benefit organizations?

Kubernetes is an open source container orchestration platform for managing, automating, and scaling containerized applications.

Containerized microservices have made it easier for organizations to create and deploy applications across multiple cloud environments without worrying about functional conflicts or software incompatibilities. This ease of deployment has led to mass adoption, with nearly 80% of organizations now using container technology for applications in production, according to the CNCF 2022 Annual Survey. However, as the use of containers has grown, so too has the need for more effective management of these highly distributed environments at scale.

To manage this complexity, teams have turned to container orchestration solutions such as Kubernetes. The platform aims to help DevOps teams optimize the allocation of compute resources across all containerized workloads in deployment.

While a handful of these solutions exist, Kubernetes has become the de facto industry standard, offering the following benefits:

• Container deployment. Container orchestration platforms automate daily operations for processes such as the re-creation of failed containers and rolling deployments. This helps to avoid downtime for end users.
• Automated scaling. Kubernetes enables efficient resource utilization by easily scaling applications and services based on demand.
• Self-healing. The platform will automatically restart, replace, or kill failed containers, as well as reschedule unhealthy pods and manage node failures. This key feature helps in maintaining availability and reduces the need for manual intervention.
• Extensibility and technology ecosystem. As an open source solution, Kubernetes has a large, active, and growing ecosystem of extensions, plug-ins, and technologies to enhance its capabilities. The ability to extend functionality across a wide range of use cases allows teams to tailor the platform to meet their organization’s specific requirements.

The top Kubernetes challenges and potential solutions

Despite its benefits, Kubernetes has some potential pitfalls that engineering leaders should consider when managing the complexity it introduces. The top seven Kubernetes challenges include the following:

1. Complexity. Kubernetes environments tend to be complex, multilayered, and dynamic. This creates limitations and blind spots when it comes to observability. Teams often need to know where to look to find issues and resolve them, but that can be time-consuming in large-scale deployments. Comprehensive platform solutions that provide full-stack monitoring with AI at their core can automatically detect anomalies and provide root-cause analysis to prevent future issues.

2. Networking. Large-scale, multicloud deployments can introduce challenges related to network visibility and interoperability. Traditional ways of operating networks using static IPs and ports simply don’t work in dynamic Kubernetes environments. Container Network Interface (CNI) provides a common way to seamlessly integrate various technologies with the underlying Kubernetes infrastructure. Additionally, service meshes — such as those offered by Istio, Linkerd, and Consul Connect — help to manage internetwork communication at the platform layer using purpose-built application programming interfaces.

3. Observability. While there are many observability and monitoring tools on the market today, most are specific in nature. A full-stack observability platform such as Dynatrace provides easy access to the three key types of monitoring signals — logs, traces, and metrics — in context. Automated data collection correlated with topology information, real-user experience, security events, and metadata makes it easier to identify issues and determine effective remediation paths. With the ability to monitor resource utilization metrics such as CPU and memory in real time, teams can optimize their operations, resulting in reduced cost and greater overall efficiency.

4. Cluster stability. Kubernetes containers are naturally short-lived and ephemeral, meaning they’re constantly being created, altered, and removed. This creates challenges in monitoring and debugging distributed applications at scale, often resulting in reliability issues. Effective monitoring, logging, and tracing mechanisms need to be in place to identify and resolve issues quickly. Additionally, ensuring cluster stability through monitoring critical components at the control plane is essential to preventing failures. To minimize negative effects, consider setting limits and alerts on CPU and memory resource requests.

5. Security. Kubernetes security incidents are primarily related to pod communications or misconfigurations that ultimately lead to delayed application deployment. Pods are not isolated, which leaves them vulnerable to malicious actors. Bad actors can use misconfigurations to gain access to sensitive data. However, Kubernetes configurations are complicated, which makes managing them at scale almost impossible. Network policies can restrict pod communications, and teams can use pod security policies to ensure pods are securely configured.

6. Logging. Logs provide critical visibility into the ongoing health of Kubernetes clusters. While Kubernetes makes it easier to generate logs from the various components and layers of a cluster, challenges remain in aggregation and analysis. Solutions that offer log management and analysis capabilities can help to streamline these efforts and provide actionable insights to teams maintaining the health of the workloads and underlying infrastructure.

7. Storage. Containers need to spin up and down easily. Therefore, they are built to be non-persistent by design. However, applications require persistent data to run successfully in production. Traditional storage solutions were not created to address these requirements, which are common among modern deployments. To ease the pain of managing storage at scale within a Kubernetes environment, Kubernetes has released features such as Container Storage Interface (CSI), StatefulSets, Persistent Volume (PV), and Persistent Volume Claim (PVC).

How a cloud-native observability and security platform can overcome Kubernetes challenges

To adequately address the complexity introduced by Kubernetes and other cloud-native technologies, organizations need more complete solutions that provide end-to-end, full-stack visibility, advanced performance and security analytics, and automated workflow capabilities all in a single, comprehensive platform.

Dynatrace integrates extensive Kubernetes observability with continuous runtime application security. This combination helps organizations more effectively meet business goals and minimize risk. The Dynatrace platform offers the following benefits:

• Automated observability at scale. As organizations deploy Kubernetes clusters across on-premises, cloud, and edge environments, end-to-end observability becomes mandatory. Dynatrace OneAgent and open ingest deliver the deepest and broadest observability on the market, with hundreds of out-of-the-box integrations covering the complete Kubernetes ecosystem. Dynatrace Grail unifies observability, security, and business data at a limitless scale for any analysis at any time.
• AI-powered analytics. Dynatrace provides precise and explainable answers in real time, identifying performance issues and anomalies across the full Kubernetes technology stack. Davis, the Dynatrace AI engine, helps organizations understand and optimize Kubernetes platform health and application performance, enabling IT teams to proactively pinpoint and rectify performance issues.
• Platform and application security. Optimized for Kubernetes, Dynatrace Application Security automatically and continuously detects vulnerabilities and protects against injection attacks that exploit critical vulnerabilities, such as Log4Shell. These capabilities remove blind spots, ensuring development teams aren’t wasting time chasing false positives and providing business leaders with confidence in the security of their organizations’ applications.
• Acceleration of innovation. Dynatrace enables IT teams to shift their effort from code maintenance and troubleshooting to innovation. Leveraging Dynatrace’s analytics and workflow automation enhances software quality, minimizes the mean time to resolve anomalies, and detects security vulnerabilities in near-real time.