Over one million organizations use Microsoft Teams as their default communication platform, resulting in a significant surge in user numbers to over 320 million worldwide in 2024. As such, MS Teams has its own set of challenges in terms of triaging, troubleshooting, and diagnosing disruptions. Phenisys has answered that challenging call and built an intricate Microsoft Teams Observability app that can help organizations answer questions like “Are you getting the best Microsoft Teams experience?”, or “Would you even know if you weren’t getting the best experience?”

Various challenges with effective Microsoft Teams observability include:

• The wide variety of potentially impacted components, for example, a network outage, an issue with a local device, or a larger outage.
• The spread of teams and employees that would potentially be included in the diagnosing and troubleshooting process, for example, SREs, IT Ops, helpdesk, or network teams.
• Native tools and data can be limited, making the correlation of user experience with potential backend issues complex.

Phenisys addresses these challenges with an app that combines AI-powered analysis, enriched metrics, and contextual data—giving teams fast and actionable insights.

In this blog post, you’ll learn how to utilize the deeply integrated features to diagnose any Microsoft Teams call issue in only three clicks:

1. Identify the troublesome call (by user name or call ID)
2. Review the call’s waterfall timeline for abnormalities
3. Diagnose the root cause of the issue(s)

Streamlined insights into Microsoft Teams performance

For the ingenuity and potential impact of their app, Phenisys was awarded first place in the 2024 Dynatrace® Partner App Competition, where partners were challenged to utilize Dynatrace AppEngine to solve real-world customer use cases. With recent statistics showing around 2.7 billion virtual meeting minutes every day (equivalent to over 5,000 years), this is certainly a high-demand use case.

Key features include:

• Home page
  Surface call-quality trends across your organization to proactively address issues before they escalate to ensure low downtime and improved user satisfaction.
• Site overview page
  Pinpoint performance hotspots and recurring issues globally across your locations to streamline troubleshooting and prioritize your investments in infrastructure.
• Call diagnostics page
  Isolate problematic calls and empower support teams to resolve issues without escalation to cut MTTR and support costs.
• Call record overview page
  Gain full visibility into user impact and root cause in minutes, allowing faster MTTR and better communication with affected teams.
• Microsoft issues page
  Stay ahead of service disruptions with real-time visibility into Microsoft-reported issues, tailored to your tenant, allowing you to inform users and adjust operations proactively.
• Configuration page
  Adjust app settings to your organization’s compliance needs and operational workflows to ensure relevance and maximum value.

Use cases

Suppose you’re on an important Teams call when you’re suddenly dropped from the call. While trying to get back in, you check with a coworker who was also on the call; they report audio issues, and someone else spams the call chat with a message stating that the screen share is frozen. As a result of this unexpectedly heavily bugged Teams call, the meeting had to be postponed, and tickets are piling up with the helpdesk.

With standard Microsoft Admin tools, the helpdesk agent can review aggregated metrics, which don’t report anything abnormal. According to the agent’s metrics, the call should have been fine, so they escalated it to the network team. Without any qualified leads, the network team has to go blind and look for possible causes. It takes two hours for someone to discover that the local WiFi router was overloaded and caused these issues. The fix is simple, but users are frustrated, and time was wasted.

With the Microsoft Teams Observability app, the same ticket can be resolved in three simple steps:

1. The helpdesk agent brings up the call either by username or call ID to check available metadata and quality indicators, such as “health.”

   

2. The agent then opens the details page to get the call timeline, including information about the performance of audio, video, and screen-sharing streams. We see a clear video degradation within the first ten minutes of the call. Thanks to the waterfall view, the agent already knows how and when the issue occurred for the user.

   

3. The agent then drills into the details. All impacted users are in the same office, so network metrics are the first point of investigation. The app highlights an abnormally high latency for that office, which is not aligned with best practices recommended by Microsoft. Within a few minutes, the agent can identify a faulty WiFi access point as a root cause, providing a clear resolution path without the need for escalation.

   

In the end, finding the root cause of the call degradation took only three clicks and mere minutes instead of hours on a wild goose chase, and instead of escalating the issue to the network team, the helpdesk agent was able to solve this on their own.

With the Microsoft Teams Observability app, workflows for operations and helpdesk teams are transformed: no more blind troubleshooting with direct and actionable insights into metrics and root cause. Tickets are no longer a black box.

Best practices

On top of all the features available, you can get even more value out of the app by utilizing a few key features and tweaking the setup to your needs.

• Utilize pre-built dashboards! To ease users into the app experience, Phenisys provides two dashboards, tracking MS Teams versions used across devices, as well as locations and users utilizing TCP streams (since Microsoft recommends using UDP ports instead of TCP). This helps users track performance over time.
• Correlate data from different call center components! With the app’s capabilities, you can view audio attendance, call queues, PSTN, and even direct routing directly within the app.
• Adjust retention periods to your needs! The app allows you certain flexibility in data retention, which can optimize data storage and support you in your efforts to align with data privacy and compliance requirements.
• Enrich data with context! Utilize lookup files to enrich your existing data with client context, ensuring more accurate and actionable insights.

Further reading

Get the app from the Hub:

• Microsoft Teams Observability

Get in touch with Phenisys:

• Phenisys partner page

Other apps built by Phenisys:

• Alicloud Extension

Other partner blog posts:

• Omnilogy Pipeline Observability
• Dynatrace® Apps showcase: Akamas Kubernetes optimization

Public videos:

• Promotional video Phenisys: Microsoft Teams Observability by Phenisys
• Dynatrace Observability Lab: Optimize Your Microsoft Teams Experience with Real-Time Insights

The post Dynatrace® Apps showcase: Phenisys MS Teams Observability appeared first on Dynatrace news.

But we’d be remiss not to invite the creative and demanding cooks of the developer world into the kitchen itself. That’s why we’ve opened up access to the world-class environment we’ve built, complete with carefully sourced ingredients and precision tooling.

In that spirit, we follow a simple mantra: build for builders. We use what we ship, and ship what we build. That’s what drove the recent launch of the Dynatrace MCP Server, designed to equip developers with observability context and security. The result? Faster fixes, safer code, and superior performance.

But our commitment to developers goes even further. To ensure that our app teams can ship confidently and quickly, we’re focused on delivering exceptional developer experience: striving for faster, more reliable, and user-friendly tooling.

And because we share our tooling with customers and partners, every improvement we make benefits the broader community. That’s why we launched App Toolkit 1.0: a developer-first toolkit that reflects our commitment to support builders. It equips teams with the means to craft custom apps and solutions on the Dynatrace platform with greater speed, flexibility, and clarity.

From SREs building apps to automate quality gates and monitor MS Teams, to dev teams diving deep into CI/CD metrics down to commit ratios; from CMDB apps that transform Smartscape® data into dynamic configuration maps, to support staff tracking container metrics, our customers and partners have built one of the broadest and most versatile collections of custom apps on Dynatrace.

Accelerate developer productivity

The App Toolkit is the developer toolchain that’s designed to turn ideas into custom apps that extend the Dynatrace platform and deliver tailored solutions for your organization. From a single command line, developers can create, develop, and deploy apps, create new app functions, or update packages.

The focus of this release is on improving developer productivity, articulated through smarter builds, automation-ready design, and a streamlined UI. This makes it easier than ever to create, develop, and maintain Dynatrace Apps.

Smarter builds for enterprises

The App Toolkit 1.0 allows for smarter builds that dramatically cut development and deployment time while improving support for building large-scale apps. Key performance enhancements include the change detection system and enhanced type checking.

The new change detection system improves performance by only building and checking components with actual changes instead of scanning the entire codebase. This means that the dev server triggers re-builds whenever changes are made during development, ensuring that the latest updates are immediately reflected in the browser. This significantly optimizes rebuild times: going from an average of 2.7 seconds in the previous version to just 0.05 seconds, a 54-fold increase in speed.

Enhanced type checking operates seamlessly in the background when initializing a new workspace. Developers no longer need to wait for type checks to complete before proceeding. This allows teams to build custom apps for large codebases with hundreds of files, where comprehensive type checking is a bottleneck. The newly introduced incremental type checking ensures that recent changes and relevant code are prioritized, facilitating robust typing practices even in larger projects.

The combination of both features significantly accelerates feedback loops. Since only modified files and their dependencies undergo re-checking, with background type checking turned on, type errors are identified and resolved in a fraction of the time.

Automation-ready commands for CI/CD Efficiency

The App Toolkit 1.0 introduces an enhanced CLI designed for automation. Every command line can automatically run in scripts or pipelines, making it ideal for CI/CD. Commands that accept additional parameters can now be executed with arguments and options directly in the command line, instead of being prompted every time the CLI needs input. Builds and deployment processes stay automated, consistent, and repeatable, ultimately accelerating delivery.

A brand-new interface for faster, error-free development

The enhanced command line interface features a redesigned command structure. All available commands are now easier to discover and use consistently and intuitively. Each command now supports a comprehensive set of parameters as options, allowing developers to access the full capabilities of the in-pipeline automations.
The CLI has improved interactions for workflow continuity. For instance, when creating a function, the output now displays all generated files within a file tree, offering clear feedback on the results of each action.

The smarter workspace setup now features a distinct separation between the user interface components and Dynatrace app functions. This offers transparency into the workspace structure and minimizes errors, particularly relevant to enterprises dealing with increased application complexity and size. Furthermore, we’ve introduced suffixes for Dynatrace Apps functions and other conventions, significantly reducing configuration complexity.

Ready to get started?

Getting started with the App Toolkit is as straightforward as it is powerful. To kick off your build, ensure your environment meets the minimum requirements, then run the following command in your code editor terminal:

npx dt-app@latest create

Next, we recommend installing the Dynatrace Apps extension for VS Code or Cursor. For documentation, examples, and best practices, head over to Dynatrace Developer and explore everything you need to build with confidence.

The post Build Dynatrace® Apps faster, simpler, and smarter with the new App Toolkit appeared first on Dynatrace news.

Dynatrace partners are a cornerstone of our success, driving innovation and enabling customer growth. Our partners from around the world are highly skilled and experienced organizations, equipped with specialized resources to implement custom use cases on top of Dynatrace as part of their broader solutions and services portfolios.

Benefitting from the openness of the Dynatrace platform, our partners can build custom solutions on top of the vast observability data ingested by Dynatrace, creating apps that address unique business challenges. This capability allows our partners to apply their domain expertise, solve real-world problems, and add value for our joint customers. By leveraging the secure and governed Dynatrace platform, partners can ensure compliance, eliminate operational burdens, and keep data safe, allowing them to focus on creating custom solutions that add value rather than managing overhead and underlying details.

For the 2024 Dynatrace Partner App Competition, we invited all our partners to showcase their ingenuity in developing impactful apps that solve real-world customer use cases using Dynatrace AppEngine. Unlike last year’s competition, which was limited to Dynatrace Pro-Club members, this year’s challenge was open to all Dynatrace partners. We’re thrilled to announce the winners of this competition, who demonstrated exceptional innovation and creativity in their solutions.

Partners add value to the Dynatrace Platform with native solutions for custom use cases

The leading entries in the competition demonstrated their ability to solve complex business challenges while delivering great user experiences. All winning apps add significant value to the Dynatrace Platform by implementing custom use cases as native apps powered by AppEngine.

This year’s winner: MS Teams Observability

The winning app, MS Teams Observability, by our partner Phenisys, helps customers ensure a seamless, high-quality Microsoft Teams experience with real-time insights. Many large organizations rely on MS Teams for fast and efficient communications, making its reliability critical for smooth business operations. By providing accessible telemetry data and scalable analytics, MS Teams Observability empowers helpdesk and operations teams to efficiently manage and resolve MS Teams performance issues and restore normal operations.

This is a great example of how partners can customize and extend the Dynatrace platform for business-critical use cases using the same tools as Dynatrace developers. Naturally, we were really excited to meet up with the Phenisys team at Perform to personally hand over the well-deserved award.

Hot on the heels: Spica Solutions and Your Compass

The intense competition made it difficult to choose between first, second, and third place. Spica Solution’s CMDB app secured second place because it effectively addresses a significant business need. The app reuses the observability data that customers already have available through the platform, making it a more reliable, secure, and cost-effective solution compared to exporting data to another CMDB system, which would require additional management.

Third place goes to Your Compass for its Patch & Inventory Management app, which enables customers to get an overview and track the support status of their hosts’ operating systems and receive alerts as they approach end-of-life.

Powerful apps built by you, run by Dynatrace

This competition is about more than just winning; it’s about exploring new frontiers in observability and celebrating the art of the possible. AppEngine enables partners and customers to develop secure, enterprise-grade custom solutions that seamlessly integrate with the Dynatrace platform. I encourage you to explore our AppEngine-ready partners. These certified app developers have a strong track record of building exceptional Dynatrace® Apps. To get started with custom apps yourself, head over to the Dynatrace Developer portal and try our Quickstart guide, which helps you create your first app in under five minutes. Don’t forget to check out our other custom solution blog posts for more insights and inspiration for leveraging Dynatrace for your unique needs.

Thank you for following along with the competition, and we look forward to seeing the innovative solutions you’ll create in the future!

The post Celebrating innovation: Top Custom Solutions from the 2024 Dynatrace Partner App Competition appeared first on Dynatrace news.

This blog post explores how customers and partners benefit from the Dynatrace platform’s openness and extensibility. We’ll further learn how Omnilogy developed a custom Pipeline Observability Solution on top of Dynatrace and gain insights into their thought process throughout the journey.

The impact of limited visibility in CI/CD pipelines

The journey for Omnilogy started when a customer explained that they needed a way to monitor and improve the performance of their CI/CD pipelines with Dynatrace. As modern agile software development relies heavily on automated CI/CD pipelines to swiftly build and deploy releases multiple times daily, these pipelines must be reliable and high-performing. However, observability across different CI/CD pipeline vendors remains inconsistent, making it difficult to understand the reason behind slow-downs or pipeline failures. This lack of comprehensive visibility into the performance of CI/CD pipelines poses a significant challenge, as they’re vital to the software delivery process. Without detailed insights, organizations risk encountering development downtime and pre-production delays due to slow builds or increased failure rates. Consequently, troubleshooting issues and ensuring seamless software deployment becomes increasingly tricky.

Build a custom pipeline observability solution

With these challenges in mind, Omnilogy set out to simplify CI/CD analytics across different vendors, streamlining performance management for critical builds. The goal was to develop a custom solution that enables DevOps and engineering teams to analyze and improve pipeline performance issues and alert on health metrics across CI/CD platforms. Faced with these requirements, Omnilogy carefully evaluated the following two options for implementing a solution to the pipeline observability challenge.

Option 1: Build a custom solution using several (open source) frameworks

Do-it-yourself (DIY) was the only option before composable enterprise software platforms became popular. With all the data readily accessible via the CI/CD tool vendor’s APIs, it’s easy to conclude that building a custom solution from scratch is straightforward. But DIY projects require extensive planning and careful consideration, including choosing the right technology stack, outlining the application’s framework, selecting a design system for the user interface, and ensuring everything is secure, compliant, and scalable to meet the requirements of large enterprises.

Omnilogy soon realized that creating a Pipeline Observability solution from scratch also involved additional risks such as:

1. The framework and APIs are dynamic and will evolve, requiring regular maintenance and updates to ensure continuous operation. Addressing vulnerabilities becomes challenging when dependencies in third-party libraries or solutions are unclear.
2. A secure access management system for code repositories and pipeline configurations is necessary, as these are among the organization’s most valuable assets and must be protected from accidental access. Additionally, security requirements such as data encryption both in transit and at rest need to be implemented.
3. Finally, the cost of maintenance and administration can significantly increase due to the administrative overhead, which includes managing user access, ensuring compliance with security protocols, performing regular updates, and addressing any issues that arise from dependencies on third-party libraries or solutions.

Such an approach would have resulted in an inconsistent experience, ultimately adding another tool for the customer. Considering all factors, it became clear that, despite initial temptations, building a custom pipeline observability solution outside Dynatrace was not their best option.

Option 2: Build on top of the Dynatrace platform

Instead of the cumbersome do-it-yourself approach, Omnilogy decided to build a Dynatrace^® App (see image below), utilizing ready-made enterprise platform components such as AppEngine, AutomationEngine, Grail™, Davis^® AI, or Strato.

Thanks to the open and composable platform architecture and the provided toolset, building a custom app that runs natively within Dynatrace was straightforward and efficient. Figure 2 provides an overview of Dynatrace’s core platform components which customers and partners can leverage to build custom apps.

Developers can automatically ensure enterprise security and governance requirement compliance by leveraging these components.

Requirements

Pipeline monitoring typically consists of several steps: data collection, pre-processing, routing, getting real-time insights, and ensuring data quality. This led to a list of functionalities they wanted to cover in their app:

1. Ingest from different data sources: Jenkins, Azure DevOps, GitHub Actions, ArgoCD, GitLab.
2. Normalization of data on ingest.
3. Traceability: Present executed pipeline as trace.
4. Same DQL semantics across all CI/CD vendors’ data.
5. Intents: Ability to use Notebooks for drill-downs and Ops-specific investigations.
6. Standardized reporting across all CI/CD vendors for easy comparison, including jobs/Errors/Duration charts for Pipelines/Stages/Steps.
7. Protection of Omnilogy’s IP in this area
8. Davis AI for anomaly detection (TBD)

To better understand the background, let’s look at a simplified architecture that illustrates the Dynatrace components in use, as well as the data flow and processing mechanisms (Figure 3)

Outcome: A fully integrated custom app streamlined CI/CD performance management

Omnilogy built the app using the provided toolchain (Developer portal, sample apps, Strato design system, VS Code extensions) and platform components without any further support from Dynatrace. The final app allows DevOps and engineering teams to track overall reliability, identify critical CI pipelines, and determine which pipeline most impacts delays. Drill-downs into details from the overview page allow comparing different CI/CD vendors and offer further insights to analyze and fix bottlenecks.

With this app, Omnilogy provides a single source of truth for their customers. It enables data-driven conversations between dev- and ops teams, making it easy to identify performance issues, errors, and the reason for failed deployments.

Summary

From the customer perspective, the advantages of implementing this custom solution as a Dynatrace App rather than adopting a do-it-yourself approach are evident:

• Get more out of your existing Dynatrace investment; no additional tools or software needed
• Dynatrace is already a trusted and vetted vendor with fine granular controls for privacy, security, and data access
• Dynatrace as a single source of truth for dev and ops teams
• Shorter time to market and time to adoption as opposed to DIY

As we have seen from this example, Dynatrace can easily handle custom requirements that are not supported out of the box. As all apps run in the Dynatrace environment, they automatically meet enterprise requirements without the need to build or manage infrastructure.

What’s next

This is just one of many examples. For more insights, check out our other custom solution blog posts or visit the Custom Solutions Spotlight to see what community members have already created.

To learn more about Omnilogy, visit their Hub partner page or the Pipeline Observability App on Dynatrace Hub.

The post Dynatrace Apps showcase: Omnilogy Pipeline Observability 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.

To address this challenge, the Dynatrace App Toolkit allows you to create custom workflow actions, providing seamless integration with third-party systems. This extends the capabilities of AutomationEngine for all users in your environment.

Prerequisites

Before you begin, please make sure you have the following:

• Access to a Dynatrace environment (for example https://environment-id.apps.dynatrace.com) where you can install and access Dynatrace® Apps and run Workflows.
• Most recent LTS version of js (version 20, as of May 2024).
• IDE or text editor of your choice (VS Code recommended)

Now, consider your use case! What do you wish to automate? Is there an API available for this purpose? Write down details regarding authentication and the necessary API Calls; you can also experiment with these API calls using tools like Postman, Insomnia, Apigee, or similar.

In this example, we will query electricity prices for the next 24 hours from https://www.awattar.de/services/api (for example, at the time of writing, no authentication is required for GET https://api.awattar.de/v1/marketdata), and figure out what time of day electricity will be the cheapest tomorrow.

Let’s create an app

We’re ready to create an app and implement our first custom Workflow action.

1. Use the Dynatrace App Toolkit to create a new app:

   npx dt-app@latest create --environment-url https://<environment-id>.apps.dynatrace.com

   When asked for the name, choose something short and catchy, and adhere to app naming guidelines. In our example, we will call the app awattar-actions.

2. Once the command above has finished, you should see a new folder (based on the provided app name), which you can open directly in your IDE.
3. Within your IDE, open a new terminal window (you can, of course, also perform the same commands in a terminal window of your choice outside of the IDE) and execute the following command to verify that everything is working:
   npm run start
4. You should now be greeted with your app’s welcome page, which states, “Welcome To Your Dynatrace App.”
   
5. Stop this command in the terminal by pressing CTRL C.
6. Create a new custom workflow action using
   npx dt-app generate action fetch-data
7. Within your IDE (or File Explorer), you should be able to see newly created files in the actions folder (feel free to take a closer look at fetch-data.action.ts and fetch-data.widget.ts).
   
8. Again, run npm run start to verify the setup’s success. Feel free to take a closer look at the output of this command, as it should provide some details about the workflow action.
   
9. We now need to include our changes in the newly created action, so let’s open fetch-data.action.ts and change its implementation to the following.

   interface FetchDataInput {
     start: string | undefined;
     end: string | undefined;
   }
   export default async (payload: FetchDataInput) => {
     // Best Practice: Separate Base URL of the Service and the targetURL of the API
     const baseUrl = 'https://api.awattar.de';
     const apiEndpoint = '/v1/marketdata';
     // re-construct the URL using the built-in URL
     const targetUrl = new URL(apiEndpoint, baseUrl);
     // add query parameters for start and end (if they are defined)
     if (payload.start) {
       targetUrl.searchParams.append('start', payload.start);
     }
     if (payload.end) {
       targetUrl.searchParams.append('end', payload.end);
     }
     // use fetch to call the API
     return await fetch(targetUrl.toString())
       .then((response) => response.json());
   };

10. We also need to adapt our widget fetch-data.widget.tsx to properly reflect the two input parameters in the action: start and end. Change the implementation to what’s shown below.

    import { AutomationTextInput } from '@dynatrace/automation-action-components';
    import { FormField, Hint, Label } from '@dynatrace/strato-components-preview';
    import { ActionWidget } from '@dynatrace-sdk/automation-action-utils';
    import React from 'react';
    interface FetchDataInput {
      start: string | undefined;
      end: string | undefined;
    }
    const FetchDataWidget: ActionWidget<FetchDataInput> = (props) => {
      const { value, onValueChanged } = props;
      const updateValue = (newValue: Partial<FetchDataInput>) => {
        onValueChanged({ ...value, ...newValue });
      };
      return (
        <>
          <FormField>
            <Label>Start</Label>
            <AutomationTextInput value={value.start} onChange={(start) => updateValue({ start })} />
            <Hint>Optional - see https://www.awattar.de/services/api for details</Hint>
          </FormField>
          <FormField>
            <Label>End</Label>
            <AutomationTextInput value={value.end} onChange={(end) => updateValue({ end })} />
            <Hint>Optional - see https://www.awattar.de/services/api for details</Hint>
          </FormField>
        </>
      );
    };
    export default FetchDataWidget;

11. Now, as a final step, deploy your app to your environment using npm run deploy.

Try it out

1. To try it out, go to your environment and navigate to Workflows.
2. Create a new workflow, choose On demand trigger, and add a new task.
3. Search for the action you created, for instance, awattar, and select it.
   
4. You can omit any configuration for now. Let’s try it out; select Save and Run on the top.
5. You’ll likely get the following error message about a blocked request. Please follow the guide provided to allow outbound API access to the host.

   Error: Blocked request to 'api.awattar.de' (host not in allowlist). To find out about how to manage allowed domains.
   please visit https://dt-url.net/allow-outbound-connections

6. Once done, you can edit and rerun the workflow, and you should see a result.
   

Conclusion

We created a simple workflow action within a few minutes to fetch data from a third party API. In an additional step, we can process the received data points and figure out the minimum. This can be done using a run javascript action and the following code snippet:

import { execution } from '@dynatrace-sdk/automation-utils';
export default async function ({ execution_id }) {
  const ex = await execution(execution_id);
  const result = (await ex.result('fetchdata_1')).data;
  // Initialize with first item
  var minItem = result[0];
  // Loop over array and find the actual minimum
  for (var item of result) {
    if (item.marketprice < minItem.marketprice) {
      minItem = item;
    }
  }
  return {
    // convert start and end into something human readable
    start_timestamp: (new Date(minItem.start_timestamp)).toLocaleString(),
    end_timestamp: (new Date(minItem.end_timestamp)).toLocaleString(),
    // keep marketprice and unit
    marketprice: minItem.marketprice,
    unit: minItem.unit
  };
}

When executing this workflow, you should eventually see a result like this:

The post Build custom workflow actions using the Dynatrace App Toolkit 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.

In this blog post, we explore real-life scenarios shared by our customers, partners, and internal users at Dynatrace, offering inspiration to kickstart your own journey with custom solutions powered by AppEngine.

For many, the driving force behind custom solution development is today’s dynamic and rapidly evolving digital landscape, in which organizations find themselves in a race to automate repetitive tasks, drive data-backed decisions, and do more with less. Increasingly, organizations are exploring unified software platforms that eliminate data silos while offering both flexibility and extensibility to safeguard their investments and streamline their diverse tools.

Bring logic to data with easy-to-build apps

As a unified observability and security platform, Dynatrace is designed to be open and customizable from the ground up. By seamlessly integrating custom solutions, Dynatrace empowers data-driven decision-making, automation, and tool consolidation—all while maintaining the familiar out-of-the-box experience. The introduction of Dynatrace^® AppEngine empowers customers and partners to build custom, compliant, and intelligent data-driven applications, ushering in a new era of platform extensibility.

Custom solutions come in all shapes and sizes, providing value for customers, partners, and internal Dynatrace users. Let’s explore some real-life custom solution examples that leverage the power of the Dynatrace core platform technologies to go beyond observability.

Automate disk resizing operations with Davis AI predictive analytics

The Dynatrace Site Reliability Engineering (SRE) team was looking for a way to automatically adjust disk space for cloud volumes on a regular basis to avoid over- or under-provisioning them. They needed a way to automatically calculate the disk resizing point and the target disk size to trigger the resizing operation. Using AppEngine as the foundation, they fed disk utilization data into Davis^® AI to forecast the required resizing operation. With Automation Engine, they were able to call the cloud provider’s API to trigger the desired resizing action.

Developer Observability app provides a shared view of issues

Dynatrace production systems generate about 10 TB of log data each day, which contains valuable information about errors and other issues. Of course, development teams need to understand how their code behaves in production and whether any issues need to be fixed. With hundreds of teams, distributed systems, and terabytes of log data, this is a daunting task. The SRE team’s solution was to create a Developer Observability app that identifies potential problems in log data, grouping, triaging, and identifying the correct teams to work on fixes. The app scans all incoming logs for various patterns and uses DQL (Dynatrace Query Language) to collect context like hosts, other processes, and traces for each potential problem. The app uses Dynatrace EdgeConnect to automatically create a ticket in our on-premises Jira issue-tracking system.

The app provides a dashboard view that gives all development teams an overview of their services, reducing the required effort per issue from many hours to a few minutes.

Custom visualization of user flows

Another example comes from one of our partners, Spindox, who created a custom visualization of user flows to replace an incumbent point solution for one of their customers. 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.

AWS cloud cost analysis

To optimize cloud spend, the FinOps team at Dynatrace built a solution that automatically ingests hourly Amazon Web Services (AWS) billing data on a daily basis as BizEvents into a Dynatrace Grail™ bucket. This allows the FinOps team to use DQL to perform analysis, such as identifying how many compute resources are running that could be covered with a savings plan. DQL also allows the team to identify spikes and anomalies in their daily cloud costs. The Notebooks app is used to drill down into the origins of the costs, while Workflows is used for automatic alerting via Slack. Pre-built custom dashboards enable the team to share the hourly billing data with development teams, giving them insights into how architecture and design decisions drive costs.

Improve cloud security posture by analyzing and auto-remediating security findings

Public cloud providers offer automated tools that detect security-related events as they occur. These events require triage, analysis, and remediation by the owners of the affected resources. However, this process can become tedious with hundreds of thousands of events flooding in daily. At Dynatrace, thousands of security tickets must be generated from these events, followed by manual remediation. Once the risk is mitigated, the resource owner must validate the resolution with the security team.

Hyperscaler security events are ingested into Grail as BizEvents. Subsequently, they undergo severity-based filtering, followed by analysis and grouping based on findings and resources. Finally, actionable Jira tickets are generated for the identified issues and assigned to the relevant owners for remediation.

The possibilities are boundless

As these examples demonstrate, the possibilities are boundless, and we’ve seen many more use cases shared by our customers and partners:

• File transfer monitoring: When migrating files from one server to another, know when a file arrives, leaves, is early, late, or missing. Use Dynatrace as a single source of truth to identify missing files immediately and take corrective measures.
• Industry software monitoring: Import telemetry data emitted by industry vertical enterprise apps (such as Temenos for banking) and build a custom app to analyze and enrich the data to trigger automated actions.
• Problem enrichment: Enhance Dynatrace-detected problems with external data. For instance, when Dynatrace identifies an issue, you can pinpoint the impacted customers using Salesforce data.
• GitHub actions profiler: Analyze data generated by GitHub action workflows and get insights into their performance and efficiency.
• Business process monitoring: Create custom dashboards for business process monitoring and trigger automated remediation actions.

Remember, as an open and extensible platform, Dynatrace doesn’t confine you to pre-defined use cases. We equip you with the necessary tools and support to extend Dynatrace by leveraging AppEngine, AutomationEngine, Davis AI, Dashboards, and more. Alternatively, you can collaborate with our AppEngine-certified partners to bring your custom use case to the Dynatrace platform.

The post Automate your work with unified observability and custom solutions appeared first on Dynatrace news.

Perform is our company’s event once a year in Las Vegas, where our customers and partners visit us to learn more about our product and industry.

It was not my first time in Las Vegas. Therefore, the slot machines next to the baggage carousels and the bright lights that beamed into the night sky did not surprise me when I landed in this desert land’s organized chaos. However, it was my first time at Perform, and although I knew I would learn a thing or two in the next week, I was unaware of how beneficial taking part in this event would be.

Getting my hands dirty: Hands-on training at Perform

I was invited to join Perform to help host one of the HOT classes two days before the main conference event. These classes allow our customers and partners to learn more about specific areas of the Dynatrace product that interest them and their company. This year, the workshop-styled classes attracted nearly 1,500 attendees eager to learn more about “Power dashboarding,” “Advanced Diagnostics,” “Intro to DQL,” and a dozen other topics.

Over the two days, I helped run four HOT classes with Dirk Wallerstorfer, Radu Stefan, and Vagiz Duseev. Our classes were focused on building custom apps with AppEngine.

HOT class: Building apps with Dynatrace AppEngine

As this class name implies, we guided  attendees through the journey of building a Dynatrace app with a code-along example app. EasyTrade Analytics is a hypothetical stockbroker app developed by two members of the Platform enablement team, Sinisa Zubic and Edu Campver. The app displays account data of the virtual stockbroker “EasyTrade” and visually indicates if there have been any fraudulent activities on the accounts.

Our goal was that by the end of each HOT class, our attendees would feel confident to start brainstorming how they can use Dynatrace Apps to extend their current Dynatrace experience and to know where to go for all the resources they need to get started building their own apps.

While building the app with the attendees, we got a real sense of who our attendees were and what they wanted to achieve. And for me, it was the first time I had the opportunity to engage directly face-to-face with our customers, allowing me to put myself in their shoes and see their needs and struggles. This face-to-face interaction helped stimulate great conversation with the attendees and allowed us to go deeper into relevant topics of app development and help them get the most from the class.

Developer personas

To my surprise, I discovered that our attendees were a scattered mix across industries, with customers from airlines, healthcare, consulting, and insurance to supply chain, distribution, financial services, and likely more. This showed me how vast and versatile the Dynatrace product is and how it can be used for many use cases. And yet, our customers’ needs and wants for custom app development are quite similar.

There was one part of our class where we showed the attendees how to add annotations to the timeseries chart that will indicate the fraudulent activities in the EasyTrade analytics app. In each HOT class, this seemed to be the eye-opening moment for our attendees, where the app went from just a nice UX experience to a purposeful use case with something each of our attendees related to.

As expected, we had a wide range of coding abilities in each class, ranging from the advanced developer who finished building the app when we reached the second exercise to those who had recently started coding. One of my favorites was an attendee who had already tried to develop their app before the HOT class, having self-studied at a TypeScript and React crash course.

This proved to me that our assumption is correct: customers that want to create apps come with all types of experience in programming, reminding me of the importance of clear and well-structured documentation to ensure all levels can find the appropriate information when developing apps.

My takeaways from the HOT class

After completing the exercise, we encouraged our attendees to share what they would like to create using Dynatrace Apps. The attendees didn’t hold back and seemed more than happy to share their ideas, which caused a waterfall effect with every idea becoming more adventurous than the last; below are some of the ideas I took note of during the classes:

• An app for fraud alerts and alerts for fraudulent links.
• An app for tracking the custom user behavior of their customers.
• An app to create alerts that could be sent to their engineers.
• An app for helping diagnose bot traffic.
• An app with a highly customizable dashboard for a call center.

The big show starts

After the two days, with a mix of jet lag, early mornings, and extended teaching sessions–it didn’t stop!

In the following days, I helped manage the booth for Exploratory Analytics and Custom Solutions; this allowed me to discuss at length with our customers and many of the HOT class attendees what they wished to achieve when creating custom apps.

Additionally, I was able to sit in on many of the main stage events, learning more about the vision of Dynatrace from our CEO, Rick McConnell, and how Dynatrace faces many of the industry challenges from our CTO, Bernd Greifeneder. Even an exceptional performance from a local group of acrobats took the stage midway through the day!

Also, I sat in on one of our breakout sessions, hosted by Dirk Wallerstorfer and Paul Schumacher, who presented in a very comical way, “Dynatrace Apps: build your own in 10 minutes or less.” You can watch the recording from Perform on-demand.

Finally, I managed to squeeze in some time to record an interview for our newest episode of our YouTube series, Inside Dynatrace Apps, where I interviewed Dirk Wallerstorfer, a product manager at Dynatrace about the why and when you would want to create a Dynatrace App. You can watch the episode now on YouTube, by visiting Dynatrace Apps: Why and When.

From the HOT classes to the main conference, I would be lying if I told you I was not tired after the event. Although it left me feeling revitalized after the experience. Within a few days I had learned so much. Perform was a great event to widen my perspective, see first-hand from the customers, and learn more about the other areas of the Dynatrace product. And, of course, it’s nice to put names to the faces of many of my colleagues!

What you should do next

Are you interested in learning more about the work of us “Developer advocates” or do you want to share your personal experiences from this year’s Perform? Head over to the Dynatrace Community and let us hear your feedback or join our monthly office hours for Dynatrace App development and learn more from myself or my colleagues, Sarah and Sini.

The post Experiencing Perform: The diary of a Developer Advocate appeared first on Dynatrace news.

In the previous blog post of this series, we discussed the crucial role of Dynatrace as an orchestrator that steps in to stop the testing phase in case of any errors. Additionally, Dynatrace equips SREs and application teams with valuable insights powered by Davis^® AI. In this blog post of the series, we will explore the use of Site Reliability Guardian (SRG) in more detail.

SRG is a potent tool that automates the analysis of release impacts, ensuring validation of service availability, performance, and capacity objectives throughout the application ecosystem by examining the effect of advanced test suites executed earlier in the testing phase.

Validation stage overview

The validation stage is a crucial step in the CI/CD (Continuous Integration/Continuous Deployment) process. It involves carefully examining the test results from the previous testing phase. The main goal of this stage is to identify and address any issues or problems that were detected. Doing so reduces the risk of production disruptions and instills confidence in both SREs (Site Reliability Engineers) and end-users. Depending on the outcome of the examination, the build is either approved for deployment to the production environment or rejected.

Challenges of the validation stage

In the Validation phase, SREs face specific challenges that significantly slow down the CI/CD pipeline. Foremost among these is the complexity associated with data gathering and analysis. The burgeoning reliance on cloud technology stacks amplifies this challenge, creating hurdles due to budgetary constraints, time limitations, and the potential risk of human errors. Additionally, another pivotal challenge arises from the time spent on issue identification. Both SREs and application teams invest substantial time and effort in locating and rectifying software glitches within their local environments. These prolonged processes not only strain resources but also introduce delays within the CI/CD pipeline, hampering the timely release of new features to end-users.

Mitigate challenges with Dynatrace

With the support of Dynatrace Grail™, AutomationEngine, and the Site Reliability Guardian, SREs and application teams are assisted in making informed release decisions by utilizing telemetry observability and other insights. Additionally, the Visual Resolution Path within generated problem reports helps in reproducing issues in their environments. The Visual Resolution Path offers a chronological overview of events detected by Dynatrace across all components linked to the underlying issue. It incorporates the automatic discovery of newly generated compute resources and any static resources that are in play. This view seamlessly correlates crucial events across all affected components, eliminating the manual effort of sifting through various monitoring tools for infrastructure, process, or service metrics. As a result, businesses and SREs can redirect their manual diagnostic efforts toward fostering innovation.

1. Configure an action for the Site Reliability Guardian in the workflow. The action should focus on validating the guardian’s adherence to the application ecosystem’s specific objectives (SLOs). Additionally, align the action’s validation window with the timeframe derived from the recently completed test events.
   
2. As the action begins, the Site Reliability Guardian (SRG) evaluates the set objective by analyzing the telemetry data produced during advanced test runs. At the same time, SRG uses DAVIS_EVENTS to identify any potential problems which could result in one of two outcomes.
   
   Outcome #1: Build promotion
   Once the newly developed code is in line with the objectives outlined in the Guardian—and assuming that Davis AI doesn’t generate any new events—the SRG  action activates the successful path in the workflow. This path includes a JavaScript action called promote_jenkins_build, which triggers an API call to approve the build being considered, leading to the promotion of the build deployment to production.
   
   Outcome #2: Build rejection
   If Davis AI generates any issue events related to the wider application ecosystem or if any of the objectives configured from the defined guardian are not met, the build rejection workflow is automatically initiated. This triggers the disapprove_jenkins_build  JavaScript action, which leads to the rejection of the build.
   
   Moreover, by utilizing helpful service analysis tools such as Response Time Hotspots and Outliers, SREs can easily identify the root cause of any issues and save considerable time that would otherwise be spent on debugging or taking necessary actions.  SREs can also make use of the Visual Resolution Path to recreate the issues on their setup or identify the events for different components that led to the issue. In both scenarios, a Slack message is sent to the SREs and the impacted app team, capturing the build promotion or rejection.The telemetry data’s automated analytics, powered by SRG and Davis AI, simplify the process of promoting builds. This approach effectively tackles the challenges that come with complex application ecosystems. Additionally, the integration of service tools and Visual Resolution Path helps to identify and fix issues more quickly, resulting in an improved mean time to repair (MTTR).

Validation in the platform engineering context

Dynatrace—essential within the realm of platform engineering—streamlines the validation process, providing critical insights into performance metrics and automating the identification of build failures. By leveraging SRG and Visual Resolution Path, along with Davis AI causal analysis, development teams can quickly pinpoint issues, and further rectify them ensuring a fail-smart approach. The integration of service analysis tools further enhances the validation phase by automating code-level inspections and facilitating timely resolutions. Through these orchestrated efforts, platform engineering promotes a collaborative environment, enabling more efficient validation cycles and fostering continuous enhancement in software quality and delivery.

In conclusion, the integration of Dynatrace observability provides several advantages for SREs and DevOps, enabling them to enhance the key DORA metrics:

• Deployment Frequency: Improved deployment rate through faster and more informed decision-making. SREs gain visibility into each stage, allowing them to build faster and promptly address issues using the Dynatrace feature set.
• Change Lead Time: Enhanced efficiency across stages with Dynatrace observability and security tools, leading to quicker postmortems and fewer interruption calls for SREs.
• Change Failure Rate: Reduction in incidents and rollbacks achieved by utilizing “Configuration Change” events or deployment and annotation events in Dynatrace. This enables SREs to allocate their time more effectively to proactively address actual issues instead of debugging underlying problems.
• Time to restore service: While these proactive approaches can help improve Deployment Frequency and Change Lead Time, telemetry observability data with Dynatrace AI causation engine Davis AI can aid in improving Time to restore service.

In addition, Dynatrace can leverage the events and telemetry data that it receives during the Continuous Integration/Continuous Deployment (CI/CD) pipeline to construct dashboards. By using JavaScript and DQL, these dashboards can help generate reports on the current DORA metrics. This method can be expanded to gain a better understanding of the SRG executions, enabling us to pinpoint the responsible guardians and the SLOs managed by various teams and identify any instances of failure. Addressing such failures can lead to improvements and further enhance the DORA metrics. Below is a sample dashboard that provides insights into DORA and SRG execution.

In the next blog post, we’ll discuss the integration of security modules into the DevOps process with the aim of achieving DevSecOps. Additionally, we’ ll explore the incorporation of Chaos Engineering during the testing stage to enhance the overall reliability of the DevSecOps cycle. We’ll ensure that these efforts don’t affect the Time to Restore Service turnaround build time and examine how we can improve the fifth key DORA metric, Reliability.

What’s next?

Curious to see how it all works? Contact us to schedule a demo and we’ll walk you through the various workflows, JavaScript tasks, and the dashboards discussed in this blog series.

If you’re an existing Dynatrace Managed customer looking to upgrade to Dynatrace SaaS, see How to start your journey to Dynatrace SaaS.

The post Automate CI/CD pipelines with Dynatrace: Part 4, Validation stage 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.

We’re giving you endless possibilities. While you were bound to existing product offerings and features in the past, you now have the power to do anything you want with Dynatrace.

But we know that with endless possibilities, fear can manifest. Fear of the unknown, what to create, how to create it, and so on. But we can’t let this fear set us back! Fear is not necessary, and throughout this blog post, we will cover some key points to inspire confidence in creating Dynatrace Apps.

Developer skills are helpful but not required to get started

It’s natural to feel unsure when confronted with something new or foreign. Just opening a new user interface of a familiar tool can feel so daunting that you can find yourself asking, where did all the buttons go? I want to go back to how things were before.

Web development over the years has made some significant improvements, and the job of a developer has become more comfortable with the assisted aids, such as Chrome Developer Tools or Visual Studio code (including GitHub Copilot), that the industry now offers.

Developing Dynatrace Apps is no different, though the word “developing” suggests that this is something that only developers can do. This couldn’t be further from the truth because creating a Dynatrace app can be as simple as writing…

…into your terminal. This single line of code downloads everything you need, including the Dynatrace Apps Toolkit. Of course, there are a few other bits to consider, but even non-technical people can get started after watching this QuickStart video. I should know; I’m a developer newbie and made the QuickStart video!

By the end of the QuickStart tutorial, you’ll know how to develop, make changes, and deploy your first app without any prior developer experience. You just need a computer, a stable internet connection, and your Dynatrace environment URL.

Good developers copy; great developers paste

When joining the app development world, I came across this phrase, “Good developers copy, great developers paste,” with a critical comment underneath, “The best developers understand.”

It’s rare to find someone who wants to start something from the ground up, mainly because it is expensive and time-consuming. And that’s why it’s important to us at Dynatrace to ensure you have all the information you need to create your Dynatrace custom apps seamlessly.

Many building blocks go into creating your apps, such as the Strato design system that provides you with the fundamental and customizable UI components to make your app look the part, app functions that operate as the backend of your app and can be used within your apps for use cases like when you want to access third-party APIs within your app or need to process heavy data. You can see more use cases by visiting the app functions documentation.

To support using these building blocks, we provide you with our Dynatrace Developer documentation, which acts as a one-stop shop for all information about creating a Dynatrace custom app. Not only do we provide you with full code snippets, but we also provide extensive written and video documentation explaining each one of our tools–all to ensure that you can be one of the best Dynatrace custom app developers.

To top it off, this is the same documentation we use internally at Dynatrace—giving you the most up-to-date and precise documentation for Dynatrace custom app development. We even provide you with several sample apps that act as inspiration and a collection of best practices. These fully functional apps cover common tasks such as querying data, using the Dynatrace API, creating visualizations… and much more. You can download the source code from GitHub and kickstart your app development journey.

You’re not alone

We know there will always be moments of haze and confusion. Perhaps the documentation does not solve your problem, you have an error, or you can’t find the answer. This is why our Dynatrace Community provides you a developer space to connect with fellow Dynatrace custom app developers. Inclusive of the developer Q&A forum, where you can ask any questions related to the topics, and the developer blog section, which you’ve found as you’re reading this blog post.

So, given that you’re still reading this, you’re ready to develop your first Dynatrace app. Remember, you don’t need high-end developer skills to get started, and you have a vast amount of information to help you create features in your apps using the documentation. If all else fails, you can lean on our Dynatrace Community to help find the answers you need. As Albert Einstein said, “Everything should be made as simple as possible, but not simpler.”

What’s next?

That’s it! And, if after reading this blog post, you believe you’re ready for even more, we invite you to take a deep dive into learning the essentials of Dynatrace Apps development by visiting our Get started with the Dynatrace platform tutorial.

Relevant links

• For more information about developing apps, visit Dynatrace Developer documentation
• To create your first app, visit the Get started with the Dynatrace platform tutorial.
• For questions related to app development, visit the developer Q&A forum.
• To keep up with the latest developments and news, visit the developer blog.

The post Start strong: Words of wisdom for creating Dynatrace Apps appeared first on Dynatrace news.

Managing a Dynatrace Platform Subscription (DPS) budget requires balancing your organization’s usage of Dynatrace capabilities against a pre-defined annual budget commitment. Without adequate flexibility in the subscription model, your organization might fail to benefit from capabilities that could transform your observability and security processes. Conversely, with too much flexibility, costs may exceed your budget.

Subscription administrators typically limit team access and capability usage to avoid billing surprises. This approach is time-consuming and requires ongoing management. Also, if limits are set too low, some critical components in your infrastructure might go unmonitored, potentially negatively impacting your business. While if limits are set too high, you might pay for more monitoring than you need and exceed your budget. While there is no penalty for exceeding your DPS budget (the same rate card is applied for on-demand usage without additional fees or premium pricing), administrators need the ability to manage their subscriptions within a planned budget.

Cost monitors notify you of changes to your forecast usage

Cost monitors offer a different approach to these challenges. By using predictive AI with smart forecast algorithms that predict usage, you’re notified whenever forecasted usage is projected to exceed your defined budget or when unexpected usage spikes occur.

Cost monitors run in the background daily, automatically monitoring usage forecasts and costs. They notify you when unusual forecasts and cost events occur so you can focus on monitoring your applications, not your subscription. Cost monitors automatically notify subscription administrators without manual setup or configuration. However, you retain full control over configured thresholds and notification paths if you desire to change them. They even provide APIs so you can integrate them into your monitoring ecosystem as needed.

Smart forecasting capabilities

Cost monitors leverage the smart forecasting capabilities of the Dynatrace Platform Subscription to predict your costs through the end of your subscription period. The budget summary includes a median forecast value with an upper and lower range for each day of your subscription into the future. By monitoring the forecast cost for the end of your subscription, you can proactively plan for growth and be notified of spikes in usage to stay on top of daily spending. Usage is forecast daily and you’re notified of significant changes or forecasts that exceed your defined threshold values. This allows you to plan and make changes accordingly.

Cost monitors also track daily costs at the capability and environment levels, alerting you when daily costs exceed predicted levels. There are no thresholds to manage for cost events; cost monitors are designed to ensure that all meaningful increases are caught and notified without generating false alerts. This predictive AI technique allows you to stay on top of daily costs and be notified of unexpected cost increases.

Cost monitors also generate email notifications for specified recipients when forecast and cost events occur. By default, you are notified of all forecast and cost events. License administrators can additionally define a specific email distribution list for these notifications. This approach ensures that a responsible team member is notified about all subscription-relevant events without any upfront configuration. Proactive alerting can be used to draw attention to unusual usage in non-production environments or an unexpected increase in use for a specific capability, allowing you to plan or manage accordingly.

What’s next

Dynatrace will continue to monitor and fine-tune the cost-event detection algorithms used by cost monitors to ensure that notifications are accurate.

If you’re already using the new Dynatrace Platform Subscription model (available as of April 26, 2023), cost monitors are already running on your account! For full details on how to get the most from them, please see our Cost monitor documentation.

Additional information about the Dynatrace Platform Subscription model is also available in our DPS documentation. If you’re interested in migrating to a Dynatrace Platform Subscription, please contact a Dynatrace account representative.

The post Avoid billing surprises with smart Dynatrace cost monitors appeared first on Dynatrace news.

Without native log support, overhead and complexity grow

OpenTelemetry, the Cloud Native Computing Foundation (CNCF) incubating project, introduced standards that enable companies to instrument, generate, and export telemetry data. When combined with out-of-the-box correlation, such telemetry data provides context-rich observability. Dynatrace has supported the OpenTelemetry project for years as a key contributor and contributed to its rise to a popular open source observability framework for cloud-native software. Many global enterprises have instrumented their code to emit traces, metrics, and logs in a standardized and vendor-neutral way using OpenTelemetry.

While ingestion of OpenTelemetry traces and metrics into Dynatrace is supported, companies often prefer to collect logs in the OpenTelemetry format. Earlier this year, OpenTelemetry announced that their logs API/SDK specification is stable, making it ripe for broader adoption. This enables unified observability because logs are indispensable for troubleshooting apps, monitoring infrastructure, auditing or investigating security incidents, tracking business events, and many other use cases.

Without such a holistic view of system behavior and performance, organizations typically need to invest in separate instrumentation and integration efforts for each telemetry type, which brings additional overhead, costs, and complexity.

Unify OpenTelemetry logs, traces, and metrics in Dynatrace

Dynatrace now includes full support for OpenTelemetry logs, which provides unified observability for organizations with vendor-neutral and open-source tech stacks. Our commitment to this open standard allows you to cover all three pillars of observability with minimal configuration effort because OpenTelemetry traces, metrics, and logs can be exported to Dynatrace using the same OTLP exporter.

By ingesting OTLP logs into Dynatrace, you can utilize the Grail™ data lakehouse and its massively-parallel processing analytics engine. This allows you to eliminate log forwarding and collection solutions, which not only add maintenance overhead and complexity but can also become bottlenecks in performance and log volume throughput.

With the added support of logs to OpenTelemetry traces and metrics, Dynatrace now gives you a unified and holistic overview of observability signals, with integrated linking of traces and logs. This enables you to connect the traces in your stack directly with root-cause information in logs. One customer recently shared why working with all telemetry signals together really makes sense for them.

Native support for OpenTelemetry (OTLP) logs also supports enterprises that have highly diverse technical architectures. While Dynatrace OneAgent^® is often the preferred way of discovering and ingesting logs from traditional hosts or Kubernetes environments, there are certain environments for which OneAgent is not a viable option. As an alternative, OpenTelemetry lets you extend Dynatrace technology coverage with log data.

Generic ingest of log data now works with OTLP

Ingesting OTLP logs is now supported via the OpenTelemetry Logs Ingest API. In SaaS deployments, you can use this approach to ingest log data into Grail and analyze it via Log Management & Analytics in your environment. The same API is also available for Log Monitoring Classic for Dynatrace Managed deployments (via an Environment ActiveGate).

All you need to do is configure your OpenTelemetry collector or any other OTLP log source to send logs to the OpenTelemetry Logs Ingest API endpoint.

Start using the full OpenTelemetry set today

• OpenTelemetry log ingest is supported in Dynatrace version 1.270 and Environment ActiveGate version 1.269
• Read more about OpenTelemetry logs in Dynatrace, ingest transformations and start ingesting logs over the API

The post OpenTelemetry logs in Grail unlock full observability appeared first on Dynatrace news.

More development teams across enterprises are adopting new mobile UI frameworks, namely SwiftUI, .NET MAUI, and Android’s latest toolkit, Jetpack Compose. While these frameworks use a declarative syntax to simplify the codebase and expedite development lifecycles, they also introduce new challenges in monitoring the user experience of mobile apps. As a front-runner for auto-instrumentation in the observability space, Dynatrace has rolled out support for these technologies to expand its coverage for mobile applications. With mobile RUM, developers and their teams who have migrated their codebase to these new UI frameworks can take advantage of the benefits of the Dynatrace platform, which enable them to quickly identify errors and facilitate their immediate resolution. This allows developers to focus more of their efforts on innovation and delivering the best user experience to their customers.

High consumer expectations for mobile

In today’s digital world, mobile apps have become an essential part of our daily lives. We use mobile apps to communicate, entertain us, conduct business, shop, and much more—on the go, anytime and anywhere. As people typically spend 4.8 hours a day on their mobile devices, it’s natural that they demand a flawless experience. Among all digital channels, mobile has the lowest tolerance for bad experiences. If an app is slow, slightly buggy, or doesn’t fulfill the user’s needs promptly, it gets deleted. In many cases, an alternative app is installed. Overall, 52% of users feel frustrated by their experiences with mobile apps.

New development frameworks from the key players

Apple, Google, and Microsoft, among others, are heavily invested in development tools and frameworks. Backed by strong communities, these tools are continuously enhanced and have redefined how apps are built. Incorporating the latest advancements in technology allows companies to develop and deliver more reliable applications, resulting in smoother user experiences. To ensure consistent progress in app development, it’s crucial to stay updated and integrate these innovations into your development process.

With the introduction of Jetpack Compose and SwiftUI, the development of mobile apps has become more accessible, efficient, and streamlined. These frameworks are based on declarative syntax, which allows developers to build native UI for Android and iOS, respectively, with ease and speed. As a result, modern mobile apps increasingly use Jetpack Compose and SwiftUI to deliver excellent user experiences. According to Google’s recent announcements, approximately 23% of the top 1,000 Android apps are built with Jetpack Compose, and these numbers doubled from last year.

The importance of observability for mobile app development

An essential aspect of improving the user experience on mobile is observability. In order to make informed decisions, business owners, UX designers, and developers require data—specifically, they rely on insights from their data on a large scale, ideally in a single location. Providers of mobile apps must be able to identify issues that users are experiencing quickly so that they can address them. They also need to assess and optimize the performance of both their apps and the back end services that support them. Finally, by gaining complete visibility into user behavior, app providers can improve user journeys and achieve better outcomes for their businesses.
A key aspect of observability is the monitoring agent that a mobile app is instrumented with. This is important because the data collected—including both its breadth, depth, and semantics—play a significant role in determining the value that can be derived from automated or ad hoc analysis.

Mobile observability challenges

Mobile agents are included and shipped with their respective mobile apps, making the selection of the right agent and its configuration crucial. Frequent changes necessitate the publication of new app versions, and successful updates are dependent on users manually updating their devices. Therefore, anything that is not monitored accurately or is monitored incorrectly leads to lengthy cycles of roll-out and adoption until accurate data and answers can be obtained.

Furthermore, companies often require time from mobile app development teams to add dependencies to their agents and configure them. However, the primary goal of these teams is to develop new features and improve existing ones, which means that monitoring user experience is often a secondary concern. Therefore, it’s crucial to minimize the time and complexity required to set up a mobile agent.

Modern development frameworks pose unique challenges when it comes to monitoring. Jetpack Compose and SwiftUI, in particular, allow developers to create UI components using declarative programming. With this approach, a developer describes the desired end result and lets the framework figure out how to update the user interface. This approach simplifies development but introduces new challenges in detecting and relating user interactions with corresponding functions and context. Recognizing on which screen a particular interaction happened and providing human-readable names automatically is challenging. However, such automation is key to ensuring that developers spend less time instrumenting their apps (and that Dynatrace users can more easily make informed decisions based on analyzed data).

Dynatrace extends auto-instrumentation capabilities

The Dynatrace platform offers the best observability coupled with the least required effort for monitoring your mobile channels. Dynatrace boasts industry-leading auto-instrumentation and auto-capture of Real User Monitoring data, regardless of whether it’s for troubleshooting, performance monitoring, or optimizing user experience and business outcomes. With auto-instrumentation, Dynatrace tackles the aforementioned challenges, offering a high level of visibility into the user experience of your mobile app with no manual effort.

Based on feedback from our development community and customers, we have expanded our auto-instrumentation support to include the following technologies:

• Jetpack Compose
• SwiftUI
• .NET MAUI

Dynatrace OneAgent^® now automatically captures user interactions, related web requests, crashes, and other vital app lifecycle information when these technologies are in use (detailed functional scope varies based on the technology in use). Hence, it has never been easier to monitor the user experience of modern mobile apps.

Jetpack Compose support

Starting with the Android Gradle plugin version 8.263+, Dynatrace OneAgent offers auto-instrumentation for Jetpack Compose UI components.

OneAgent creates user actions based on the UI components that trigger these actions and automatically combines the user action data with other monitoring data, such as web request information and crashes. Currently, to get this feature set activated, developers need to manually enable Jetpack Compose auto-instrumentation. For the Android Gradle plugin version 8.271+, the instrumentation will be enabled by default. At the moment we auto-capture various types of user interactions, including

• Clickables
• Toggleables
• Swipeables
• Sliders

For complete details about Jetpack Compose UI components and user action support, go to User action monitoring for Jetpack Compose documentation.

As mentioned, analyzing user experience and identifying the specific elements with which the user interacts can be more challenging with a declarative UI. This is especially true when it comes to providing proper names and context. With the addition of Jetpack Compose support, we have developed a new method for detecting user action names. Dynatrace now evaluates four properties to generate meaningful user action names. The property value that has the most intuitive meaning is used as the name. A special sensor captures semantic information and evaluates the information from the merged semantics tree. This evaluation occurs in the following order:

1. SemanticsPropertyReceiver.dtActionName
2. SemanticsPropertyReceiver.contentDescription
3. SemanticsPropertyReceiver.text
4. Class name

With this approach, companies that use semantic properties appropriately also benefit from a better understanding of user journeys in Dynatrace user sessions.

Another key addition that helps make sense of user interactions is the auto-capture of additional metadata based on the UI component used. Metadata is stored as key-value pairs and is accessible through the Dynatrace web UI. With this additional context—for example, location in code, initial and transition states, interaction types, and more—Dynatrace makes sense of the user journey and the technical components in use. So, not only UX but also developers can retrieve the information they need to optimize user experience.

Based on each UI component, Dynatrace also automatically captures relevant metadata, including:

• The function name to make it easier to find the code behind each interaction
• The user action type, to make it easier to understand the user journey in the User session view
• And a state (from/to) to make it easier to understand the evolving state of each UI component

For full details, see Captured component metadata documentation.

SwiftUI support

Initial support for SwiftUI controls was released with OneAgent for iOS version 8.249+. With OneAgent for iOS version 8.265+, the auto-instrumentation capabilities of SwiftUI were significantly expanded to include:

• New controls and views
• SwiftUI methods(for example, onTapGesture)
• Lifecycle monitoring

SwiftUI is a declarative UI framework. Therefore, its instrumentation and monitoring pose additional challenges.

The Dynatrace SwiftUI instrumentor adds additional code to the project source code (*.swift files) during the build process in order to enable the auto-capture of UI elements. After the build process is complete, all changes to the source code are reverted.

Auto-capture support has been expanded. For details regarding which SwiftUI controls and views are supported, see Instrument SwiftUI controls documentation.

At the moment Dynatrace auto-captures various types of user interactions, including

• Buttons
• Pickers
• Sliders
• NavigationLink
• Tabview

In addition, Dynatrace now supports the instrumentation of some SwiftUI methods. When a supported method is closed, Dynatrace collects the method name, the type of view the method was attached to, and the parent view name.

Finally, Dynatrace is now capable of tracking key lifecycle events for SwiftUI views, including:

• Application start
• onAppear (for all SwiftUI views presented from a NavigationLink or a TabView control)
• onAppear (for revisited SwiftUI views presented from a NavigationLink or a TabView control)

.NET MAUI support

Starting with Dynatrace version 1.265+, our dedicated NuGet package helps auto-instrument your .NET MAUI mobile application.

.NET MAUI is a cross-platform framework for creating native mobile apps and more. It’s a combination of open source code and the evolution of Xamarin.Forms that enables developers to use a single code base to cover as much of app logic and UI layout as possible. The repo has been starred by ~19,000 users and receives regular updates and pull requests.

The Dynatrace NuGet package is used to instrument your mobile applications with OneAgent for Android and iOS. The supported feature set is similar to Xamarin.

Auto-instrumentation support is available for:

• User actions
• Lifecycle events
• Web requests
• Crashes

…plus, a wide range of options for manually instrumenting your app.

Conclusion

Regardless of whether you have a Dynatrace SaaS or a Dynatrace Managed deployment, update OneAgent for Mobile today to leverage the latest observability innovations and benefit from immediate visibility and fast value-creation with the unique end-to-end visibility Dynatrace provides!

The post Dynatrace RUM expands coverage for modern mobile UI frameworks appeared first on Dynatrace news.

In Part 1 of this blog post series, we introduced the concept of security policies in preparation for upcoming enhancements to the Dynatrace platform. Security policies give authorized users access to Dynatrace capabilities, such as Grail and its add-ons, exploratory analytics, and Dynatrace AppEngine.

Modern authorization concepts for the Dynatrace platform

With the introduction of Dynatrace Grail™ and AppEngine, we’re changing how access management is provided on the new platform. The new architecture enables more granularity in permission management and provides the dynamics necessary to serve modern access management use cases.
We’ve replaced the role-based permission system with security policies that provide fine-grained control over service access and introduce new dynamic controls for user authorization.
Dynatrace administrators must now set three permission types to ensure that users benefit from the latest platform capabilities.

• Permission to query data stored in Grail
• Permission to run and access Dynatrace® Apps
• Permission to access supporting services

Managed security policies

Managed security policies are used to assign permissions to users and simplify the configuration of access permissions without the hassle of dealing with all the fine-grained permissions in the Dynatrace IAM permission system. The managed policies cover the essential access scenarios that administrators face and can be used to conveniently set up more complex permissions. When there is a need for more customized access control, administrators can create their own policies.

Dynatrace offers a set of managed policies that cover standard use cases for accessing the new capabilities of the Dynatrace platform: AppEngine, AutomationEngine, and Grail. The managed policies always reflect the latest changes in the Dynatrace platform and its underlying permission system and, therefore, can’t be customized.

Security policies for granting platform access

Administrators can find the policies managed by Dynatrace in the policy overview in Account management and bind them to user groups just like any other policy. These policies are of type Dynatrace managed.

Policies can be assigned to groups via the user group details either on the account level, which includes all tenants in that account, or on the individual environment level.

The following section offers an overview of the managed policies available for Grail™ and AppEngine, which you can use to give your users access to these new capabilities.

Grant users basic access to AppEngine

AppEngine user policy

This policy provides basic access to AppEngine to run apps and functions and access the main supporting services (such as the state service, document service, or document sharing).

ALLOW app-engine:apps:run, app-engine:functions:run;
ALLOW automation:workflows:read, automation:rules:read, automation:calendars:read;
ALLOW document:documents:read, document:documents:write, document:documents:delete, document:environment-shares:read, document:environment-shares:write, document:environment-shares:claim, document:environment-shares:delete, document:direct-shares:read, document:direct-shares:write, document:direct-shares:delete;
ALLOW state:app-states:read, state:app-states:write, state:app-states:delete, state:user-app-states:read, state:user-app-states:write,state:user-app-states:delete, app-settings:objects:read;

AppEngine admin policy

This policy provides users full access to AppEngine, with write access to all services.

ALLOW app-engine:functions:run, app-engine:apps:run, app-engine:apps:install, app-engine:apps:delete;
ALLOW automation:workflows:read, automation:rules:read, automation:calendars:read;
ALLOW document:documents:read, document:documents:write, document:documents:delete, document:environment-shares:read, document:environment-shares:write, document:environment-shares:claim, document:environment-shares:delete, document:direct-shares:read, document:direct-shares:write, document:direct-shares:delete;
ALLOW state:app-states:read, state:app-states:write, state:app-states:delete, state:user-app-states:read, state:user-app-states:write, state:user-app-states:delete, app-settings:objects:read, app-settings:objects:write;
ALLOW settings:objects:read, settings:objects:write, settings:schemas:read where settings:schemaId startsWith "app:";

Give additional access to new platform capabilities

AppEngine developer

Add additional permissions that enable a user to develop and install custom apps

ALLOW app-engine:apps:install, app-engine:apps:delete WHERE shared:app-id startsWith “my”;

AutomationEngine access

Allows users to use the Workflows app and automation capabilities

ALLOW app-engine:apps:run WHERE shared:app-id = "dynatrace.automations";
ALLOW automation:workflows:read, automation:workflows:write, automation:workflows:run, automation:rules:read, automation:rules:write, automation:automations:run, automation:calendars:read, automation:calendars:write;

Grant access to data stored in Grail

Storage Default Monitoring Read

Administrators can use this permission to give users access to the tables and data stored in default buckets (default bucket names starts with default_). This policy will be adjusted automatically as new tables are added to Grail in the future.

Be aware that this policy only covers default buckets. Once custom buckets are added to Grail, administrators need to define additional permissions.

ALLOW storage:buckets:read WHERE storage:bucket-name startsWith “default_”;ALLOW storage:events:read, storage:logs:read, storage:metrics:read, storage:entities:read, storage:bizevents:read, storage:spans:read;

Storage Read per table

Each table includes a policy that combines table and bucket access called Storage <tablename> Read. Administrators can use this policy to grant a user group access to a certain table and the assigned buckets.

ALLOW storage:buckets:read WHERE storage:table-name = “logs”;
ALLOW storage:logs:read;

Storage All System Data Read

The Storage All System Data Read policy grants access to Dynatrace internal data such as auditing events and query execution events. Administrators can add this policy to those users that need access to this type of data.

ALLOW storage:buckets:read;ALLOW storage:system:read;ALLOW storage:events:read, storage:logs:read, storage:metrics:read, storage:entities:read, storage:bizevents:read,storage:spans:read;

Storage All Grail Data Read

This policy grants unfiltered access to all data in Grail.

ALLOW storage:buckets:read;
ALLOW storage:system:read;
ALLOW storage:events:read, storage:logs:read, storage:metrics:read, storage:entities:read, storage:bizevents:read,storage:spans:read;

For full details, see bucket and table permissions for Grail documentation.

Auto-migration for environment admins and default user groups

To make the initial setup more convenient, we auto-assigned AppEngine, AutomationEngine, and Grail policies to existing admins in each Dynatrace environment.

Every user group with permission to change settings receives the respective admin policies for AppEngine and Grail. This means every environment admin is automatically assigned the policies AppEngine Admin, AutomationEngine Access, and Storage All Grail Data Read.

Automate policy assignment via IAM APIs

To automate the above-mentioned policy management or to automatically provision users with the proper privileges, please use our IAM APIs, which can be found at api.dynatrace.com as part of the Account management API.

Use the bindings endpoint in the Dynatrace Account Management API to assign managed policies to user groups.

Pro tip: Notebooks migration script

The newly introduced Dynatrace Notebooks allows you to run custom code using AppEngine. We created a script that helps administrators easily migrate existing platform-access permissions for all users—just add and execute the script to any notebook after providing OAuth client credentials for the account that needs to be migrated with the following OAuth scopes assigned:

• account-idm-read
• iam-policies-management

This script crawls the entire account and identifies the user groups with Viewer access to the environments. It then creates the new policy bindings for AppEngine and Grail based on the existing role-based permissions.

Head over to Dynatrace Community to download the script, get support, or ask any related questions.

What’s next

To learn more about how to manage policies within Dynatrace IAM, see Dynatrace Documentation and Part 1 of this blog post series.

Once you’ve started working with policies, we’d love to hear your feedback: let us know your thoughts or share your ideas about how we should continue to enhance authorization settings in Dynatrace.

The post Tailored access management, Part 2: Onboard users to Grail and AppEngine appeared first on Dynatrace news.

There are many definitions of environmental sustainability, most of which converge on a common theme. Collectively and individually, we have a responsibility to act to protect global ecosystems and support health and wellbeing, now and in the future. Sustainability seeks a balance between human activity and the natural world.

As a result, environmental sustainability is one of the three pillars of environmental, social, and governance (ESG) initiatives. ESG embodies a set of criteria that guides an organization’s strategy, measures the organization’s impact, and informs potential investors across these three pillars. Specifically, the environmental criteria focus on an organization’s utilization of natural resources and the resulting impact on the environment. McKinsey summarizes the importance of this focus. “Every company uses energy and resources; every company affects and is affected by the environment,” the article states. ESG metrics are increasingly important to investors as they evaluate risk. In turn, these metrics are increasingly important to organizations because they measure and disclose their performance.

Balancing act or tipping point?

What motivates us to act? The answer, to varying degrees, is favorable investment potential, regulatory requirements, competitive advantage, cost savings, and moral imperative. And the time to act is now. In fact, in an article for the Wall Street Journal, Gartner analyst Stephen White anticipates that organizations will rapidly adopt performance metrics tied to energy consumption. “Sustainability is increasingly becoming a board-level issue with broad companywide mandates flowing down from chief executives to tech leaders,” White says.

Regulatory mandates are another driver that organizations can’t ignore. As a result, the Securities and Exchange Commission (SEC) in the US and the European Parliament in the EU are adopting stricter reporting rules that will apply to a larger number of companies. Globally, the International Sustainability Standards Board (ISSB), established at the UN Climate Change Conference in Glasgow, has developed requirements for climate-related disclosure. Sustainability reporting informs investors about sustainability risks and helps focus a company’s sustainability actions.

Your IT carbon footprint

Corporate carbon footprint calculations consist of multiple facets, including transportation, waste management, fuel, and electricity consumption. To that end, measuring, understanding, and reporting results are important precursors to intelligent reduction actions.

From an IT perspective, the sustainability focus is on carbon emissions from electricity consumption, specifically related to on-premises, hybrid, and multicloud computing. Some interesting facts:

• Moving a workload to the cloud can reduce its carbon footprint by up to 96%.
• Cloud computing has a greater carbon footprint than the airline industry.
• Average cloud server idle time exceeds 70%.

Yet most organizations don’t have the tools to measure, much less reduce, their IT carbon footprint.

Measuring your carbon footprint: from intention to action

Cloud providers offer tools to measure carbon emissions from the use of their cloud services. But these tools don’t support multicloud environments, and they don’t account for the footprint of on-premises services. More importantly, these tools are fundamentally backward-looking. They lack both the time and dimensional granularity required to derive carbon-emission analytics and optimization insights. Environmental sustainability emphasizes our collective responsibility to take action. For this, we need real-time intelligence and analytics, not just historical reports.

As executive mandates reach technology leadership teams, your organization’s carbon reduction goals will become more tangible. As a result, you’ll need to shift from intent to action, from passive reporting to active reduction initiatives.

Introducing Carbon Impact

The Carbon Impact app from Dynatrace measures and reports the carbon footprint of all Dynatrace-monitored hosts across your entire hybrid and multicloud environment in a single interface. The app translates utilization metrics, including CPU, memory, disk, and network I/O, into their CO2 equivalent (CO2e). Dynatrace engineers developed the app using guidance from the Sustainable Digital Infrastructure Alliance (SDIA), expanding on formulas from Cloud Carbon Footprint.

With Carbon Impact, you can explore the sources of your IT carbon footprint, regardless of where your workloads run. The app automatically identifies opportunities to reduce carbon emissions, capturing the details needed to analyze and make informed decisions. It also generates granular reports and host-level details to provide a focus for carbon reduction initiatives.

The Carbon Impact dashboard: Your IT carbon footprint overview

The Carbon footprint summary reports total CO2e emissions for the selected and preceding timeframes for quick interval-based comparisons.

Optimization summaries report idle instances and under-utilized instances. The app derives thresholds that influence these calculations from Google Compute Engine recommendations, although you have full configuration control to adjust these thresholds to your needs.

The table breaks down emissions by data center, listing your cloud and on-premises instances. All your carbon footprint data is in one place, and the measurement methodology is consistent across all your data centers.

Two charts complete the dashboard. The first shows accumulated carbon footprint and energy consumption over time. As cloud providers decarbonize their data centers, or as you move your workloads to more carbon-efficient locations, the slope of the carbon emission trajectory should change to illustrate the impact. The second chart allows you to compare carbon emissions over time with a business metric of your choice derived from any of your configured business events.

Instances: Where should you focus your attention?

The Instances view details energy and CO2e consumption per host instance. Filters help narrow your focus. For example, you could view underutilized instances in a specific AWS data center or top CO2e emitters within a specific host group. Because Carbon Impact automatically connects to Dynatrace Smartscape® topology modeling, it’s easy to drill into host and process details. Or you can open Notebooks for ad hoc analysis, arming your teams with the insights needed to evaluate opportunities to reduce carbon emissions.

Carbon Impact and Dynatrace AppEngine

Carbon Impact tracks, reports, and helps you reduce the carbon footprint of your cloud and on-premises infrastructure. It also provides data center, host, process, and application details to help you understand where to focus your efforts. Moreover, it provides recommendations to help you get started quickly. Significantly, Carbon Impact supports multiple audiences, including compliance teams as a source for reporting, business teams that need investment guidance, and operations teams that need to act to reduce their carbon footprint.

Carbon Impact is a purpose-built app we created using the new Dynatrace AppEngine. It addresses a well-defined business need, bringing custom analytics to Dynatrace data stored in Grail. Carbon Impact is available now on the Dynatrace Hub. To learn more, please contact your account team.

The post From observability to sustainability: Reduce your IT carbon footprint with Dynatrace Carbon Impact appeared first on Dynatrace news.

Many organizations attempt to combine tools, products, and do-it-yourself solutions with custom code to fulfill custom use cases that are specific to their unique business requirements and technology stacks. Not only are these approaches difficult and costly to maintain, they also lack proper security and scalability.

Especially when seamless end-to-end solutions are needed, it’s necessary to add relevant business context to data to unlock the value of insights that are hidden in the vast amount of observability, security, and business data derived from modern clouds, and overcome the challenges of data that’s locked in organizational silos.

AppEngine empowers organizations to tame cloud complexity, innovate faster and more securely, and ensure consistently better business results, thus delivering answers and driving collaboration across teams.

Multiply the value of your data with Dynatrace

In contrast to other custom app development solutions and extensibility frameworks that embed third-party interfaces and self-hosted custom code via iFrame, Dynatrace AppEngine enables you to create custom apps tailored to your specific needs that are integrated into the Dynatrace platform and offer a simplified user experience.

AppEngine is a core technology within the Dynatrace platform. It empowers Dynatrace customers to use the same tools and technologies as Dynatrace engineers to develop new tailored apps. App developers have the same limitless possibilities for creating customized analytics and integrations in any IT environment, whether in the cloud or on-premises. Apps enable organizations to leverage a goldmine of observability, security, and business data—and add further value by addressing any imaginable use case.

Boundless possibilities

You now have unlimited possibilities to address any use case you can imagine. Consider a simple interactive app that helps convey the business impact of new product enhancements by combining IT Ops metrics with business data—or an app that not only calculates the costs of your cloud usage but also automatically optimizes it by leveraging the power of Davis, our causational AI, and the new Dynatrace AutomationEngine. Or imagine a vulnerability notification generated by Dynatrace Application Security triggering a custom security app that initiates a fully automated action flow, informs your SecOps team, and creates and assigns tickets to the right people with all the relevant contextualized information. These and an unlimited array of other use cases are now possible with AppEngine.

We’re also releasing a variety of apps that we developed using AppEngine. These will be built into the Dynatrace platform and address use cases ranging from automation to security and business analytics, and include apps such as Smartscape Health View, Carbon Impact, and Site Reliability Guardian.

Dynatrace Carbon Impact is a perfect example of combining data stored in Dynatrace with external data and custom logic to explore and visualize the sources of your IT carbon footprint, regardless of where your workloads run. It measures and reports carbon emissions for all Dynatrace-monitored hosts across your entire environment, including hybrid and multicloud, in a single interface and translates utilization metrics, including CPU, memory, disk, and network I/O, into carbon emission metrics. The app automatically identifies opportunities to reduce carbon emissions, capturing the details needed for analysis and making informed decisions.

From code to app to code

Apps built with Dynatrace AppEngine can take different forms. From full-blown apps addressing end-to-end use cases, like the Carbon Impact app example shown above, to small “components” that focus on a particular task, such as:

• offering integration with external line-of-business (LOB) applications
• connecting apps with external databases, normalizing data for immediate platform-wide usage
• extending the Dynatrace AutomationEngine with new custom actions
• adding reusable UI components to extend Dashboards and Notebooks with new chart types

Once you write an app, you can use it everywhere within the Dynatrace platform: within Notebooks, as part of a workflow running on AutomationEngine, or as a standalone app.

Logic to data: Understanding the value of data at its source

Many data-related requirements, such as GDPR, governance, data quality, or auditing, must be addressed when writing software. These requirements are mandatory from both a performance and a cost perspective.

Analyzing petabytes of data only works if the logic is very close to where the data is stored and processed. Grail, the Dynatrace causational data lakehouse, is built for managing and querying enormous amounts of data from the entire hybrid and multicloud environment. Utilizing the capabilities of Grail together with Smartscape topology mapping and Davis AI, AppEngine understands the IT, security, and business value of data in context. This contextual understanding enables you to do any analysis you need and helps to answer questions that can’t be answered with disconnected data stored in different silos.

Addressing enterprise needs: Security, scalability, and manageability

Traditionally, building apps and integrations on different enterprise software platforms was tough and required a lot of effort. By using Dynatrace AppEngine, developers can focus their time on adding value by meeting the urgent needs of the business instead of managing integrations and runtime infrastructure or addressing security needs. The apps run in the Dynatrace environment, thus automatically meeting enterprise requirements. This provides benefits including:

• auto-scaling runtime environments
• automated delivery and operations
• governance by Dynatrace Identity and Access Management (IAM)
• built-in security capabilities such as code shielding, secure runtime environment, audit logs, SSO, secret vaults, and more
• safe connection for secure remote invocations using EdgeConnect

And all of this comes with full app-lifecycle support, including extensive developer experience for creating, building, deploying, and managing apps.

Data value at scale: Become a data-driven enterprise

Dynatrace AppEngine enables teams to achieve better business results by offering a secure, serverless, auto-scaling runtime environment that makes it easy to create custom, compliant, data-driven apps, that address the use cases that are most important to them.​

Everything thinkable is now possible. With apps delivering answers and driving collaboration across IT, development, security, and business teams, you can multiply the value of your data.

Dynatrace AppEngine will be available in Q2 2023. In the meantime, look for upcoming webinars sharing more insights on the app offering of the Dynatrace platform and how to build your own custom apps. Visit our webpage or follow us on LinkedIn to stay current with upcoming announcements and activities.

The post Dynatrace AppEngine: Everything thinkable is now possible appeared first on Dynatrace news.

Today, IT and development teams have myriad responsibilities in managing and working with cloud environments. They need to create new products and maintain existing ones to deliver customer value at speed and scale while managing risk. Therefore, modern observability platforms are becoming a must-have tool for these teams.

Teams can now use an observability platform to unify operations, business, and development data to gain automatic, precise answers about cloud environments and user experience. Further, developers can build more agility into their processes with an intuitive, low-code approach to create custom, compliant, and intelligent data-driven apps and automation.

The ability to create custom apps becomes increasingly important as organizations strive to innovate and grow. They want to develop secure, compliant custom apps and integrations—whether in the cloud or on premises. Indeed, according to one report, more than 50% of U.S. organizations have over 100 custom applications in development and testing today.

A modern observability platform like Dynatrace is uniquely positioned to serve as a foundation that enables teams to build low-code, custom apps that are secure, compliant, and based on precise answers. And with Dynatrace AppEngine, IT pros have the tools to build custom apps that serve their organization’s business needs and fit in their multicloud ecosystems.

The convergence of observability and security data

Organizations now realize that better understanding their applications and cloud environments is the key to assessing their health from both performance and security perspectives. Therefore, leaders are embracing a converged security and observability approach by unifying all observability and security data in a single location or source of truth.

As a result, these leaders can ask different questions of the same data. And because the data is complete and in context, the answers and insights are always accurate, resulting in an increased trust of these data-backed insights. As development and security teams work more closely together, they also recognize the importance of converging observability and security data to deliver answers and insights through secure, compliant, enterprise-grade applications.

Dynatrace AppEngine supports these goals and empowers customers and partners with an easy way to create and share custom apps for their IT, development, security, and business teams. With consistent answers and insights, organizations can solve their toughest business challenges.

Unifying data, retaining full data context

The Dynatrace platform now uniquely consolidates observability, security, and business data while retaining full context and dependency mapping with its data lakehouse, Grail. Additionally, its modern architecture delivers cost-effective storage and compute. As a result, teams benefit from low-cost cloud storage that provides access to all data and doesn’t require data rehydration. This frees teams from manual approaches to connecting siloed data—using imprecise machine-learning and correlation-only techniques—and the high total costs of using multiple DIY-style solutions.

AppEngine uses this data and simplifies intelligent app creation and integrations for teams throughout an organization. It provides automatic scalability, runtime application security, secure connections and integrations across hybrid and multicloud ecosystems, and full lifecycle support, including security and quality certifications. As a result, for the first time, any team in an organization can create intelligent apps powered by causal AI and build integrations for use cases and technologies specific to their unique business requirements and technology stacks.

Delivering precise answers and insights to the whole enterprise with secure apps

AppEngine is a core technology in the Dynatrace platform that enables anyone in IT, business, or security to create and share inherently secure, custom apps that leverage causal AI and data and scale well. It’s a more productive and secure approach for teams to meet requirements without undermining an organization’s security posture. By using these secure apps, teams are empowered with powerful mechanisms for collaboration and insight-sharing across domains.

AppEngine is built for enterprise software development needs

The custom applications that teams develop run in the Dynatrace environment and automatically meet enterprise requirements, such as scalability, availability, performance, scale, governance, and full lifecycle support.

AppEngine provides a runtime environment that automatically scales the environment, ensuring the application is highly available and performing healthily. Additionally, AppEngine handles security and compliance by leveraging the capabilities of the Dynatrace platform, including access control, secrets management, audit logs, and app signing. Further, the EdgeConnect capability allows secure connections to on-premises systems. This ensures users do not damage the enterprise’s security posture with insecure rogue applications. And, lastly, it provides full lifecycle support with a rich developer experience to create, deploy, and manage applications easily.

Endless possibilities with custom apps powered by observability, security, and business data

Dynatrace customers and partners can now easily bring their business logic to data and create applications on the Dynatrace platform. Dynatrace tames the underlying complexity of managing data in a cost-efficient, performant way, ensuring the integrations with an organization’s ecosystem solutions are inherently secure and everything runs and scales in an automated way. This allows teams to focus on quickly creating apps and sharing with others to promote collaboration and data-backed decision-making.

The following apps showcase the power of AppEngine and the diversity of use cases it can address:

• Smartscape Health View. Teams can visualize an application’s vital signs, including its security posture. This app also showcases AppEngine’s ability to unlock actionable insights from data through enrichment, visualization, and analytics.
• Site Reliability Guardian. This enables teams to proactively maintain service-level objectives by automating quality and security gates. This also exemplifies how apps created using AppEngine fuel answer-driven automation to optimize cloud operations.
• Carbon Impact. Organizations can understand and reduce the carbon footprint of hybrid and multicloud ecosystems. This also demonstrates how AppEngine can help teams measure and optimize the key performance indicators that matter most for business executives or regulatory requirements.

This newfound agility in packaging and delivering data-driven answers and insights in a secure, compliant way is highly beneficial for customers seeking to use data for automating insights and actions.

Taking your data insights to the next level

At Perform 2023 in Las Vegas, Dynatrace announced a host of platform enhancements to enable IT pros to move from data in context to insights on which they can execute with confidence. The platform has been updated with a variety of capabilities to enable teams to discover data insights more easily:

• expanded Grail data lakehouse to support new data types, such as metrics and distributed traces, and enable exploratory analytics with causation powered by topology and dependency mapping;
• a new user experience for collaborative and exploratory data analytics using Notebooks;
• Dynatrace AutomationEngine for automating BizDevSecOps workflows driven by answers from causal AI; and
• Dynatrace AppEngine with a low-code tool set and application programming interfaces for building and sharing custom, compliant, data-driven apps.

To learn more about Dynatrace AppEngine and how to create low-code applications for exploratory analytics, check out our on-demand Perform sessions.

The post AppEngine empowers organizations to create custom apps for better data insights appeared first on Dynatrace news.