Dynatrace-Associate Questions and Answers

When a platform is not supported by OneAgent, Dynatrace provides alternative methods to ingest metrics:

OpenTelemetry allows ingestion of metrics using open standards, enabling integration with unsupported platforms by exporting telemetry data into Dynatrace

Dynatrace Extensions (especially Extensions v2) allow users to collect custom metrics from technologies that are not natively supported

Installing ActiveGate alone does not enable metric ingestion unless it is used in combination with extensions or APIs. Creating a Dynatrace App is unrelated to metric ingestion and is instead used for building custom UI or workflows within the platform.

When monitoring Kubernetes, Dynatrace provides multiple relevant data sources:

Prometheus metrics – ingested and analyzed alongside other metrics

Infrastructure-level metrics – CPU, memory, disk usage from nodes

Kubernetes-specific events and metrics – pods, deployments, namespaces, cluster events

Other options:

Code-level insights relate to application tracing, not Kubernetes data sources directly

OpenKit is used for custom user session tracking, not Kubernetes monitoring

The Waterfall analysis view provides detailed W3C timing breakdowns for web pages and resources. It visualizes how each resource loads, including DNS lookup, connection time, SSL negotiation, request/response time, and rendering.

This allows users to:

Identify slow-loading resources

Analyze frontend performance issues

Understand page load behavior in detail

Session Replay focuses on visual playback of user sessions.

Distributed Traces focus on backend request flows.

Extensions v2 are unrelated to frontend timing analysis.

The dt.security.context attribute enables fine-grained access control over ingested data, including Business Events.

It allows:

Segmentation of data

Restricting access to specific users or groups

Applying security boundaries to sensitive datasets

Other attributes are related to tracing:

dt.traceid and dt.spanid are for distributed tracing

dt.entity.process_group_instance links data to entities

Only dt.security.context provides control over data access and segmentation.

Dynatrace allows adding versioning and metadata to monitored entities through multiple configurable inputs:

Events ingestion can be used to push deployment and version information into Dynatrace, which is then associated with entities

Kubernetes labels allow attaching version metadata (such as app version or build number) to workloads and pods

Environment variables can be used to define version information that OneAgent automatically captures and associates with services or processes

Smartscape is a visualization tool and does not configure metadata.

Security vulnerability relates to application security findings, not version metadata configuration.

Multidimensional Analysis for User Actions is designed specifically for deep analysis of user actions with multiple filters and dimensions.

It allows:

Filtering by user action properties

Comparing across geolocations

Aggregating user actions with the same name across applications

Viewing metrics like Visually Complete time and User Action duration

Other tools are less suitable:

USQL is legacy and less flexible

Dashboards are for visualization, not deep filtering

Data Explorer focuses on metrics, not user actions

Notebooks are not optimized for this specific RUM analysis

Dynatrace provides a comprehensive observability platform including:

Application Observability – full-stack monitoring of applications

Infrastructure Observability – monitoring hosts, cloud, and containers

Business Events Monitoring – capturing and analyzing business data

Application Security – runtime vulnerability detection and protection

OpenSource is not a Dynatrace platform capability.

Objective

Create a dashboard in the new Dynatrace platform (NOT Classic) that shows:

Memory usage

For all pods

In easytrade namespace

Summed into a single metric

Timeframe = Last 30 minutes

Dashboard name = EasyTrade memory usage

???? STEP-BY-STEP EXECUTION

???? Step 1: Open Dashboards (New Platform)

Go to: ???? Dashboards & Notebooks

Click: ???? Dashboards

Click: ???? Create Dashboard

???? Step 2: Name the Dashboard

Set name exactly as: ???? EasyTrade memory usage

⚠️ Match spelling exactly (case-sensitive matters sometimes)

???? Step 3: Add a Tile

Click: ???? Add Tile

Select: ???? Data Explorer

???? Step 4: Select the Correct Metric

In the metric selector:

???? Choose:

Kubernetes container memory usage

Typical metric:

builtin:kubernetes.container.memory.usage

???? Step 5: Apply Namespace Filter

Add filter: ???? Kubernetes Namespace = easytrade

⚠️ This is CRITICAL (without this → wrong answer)

???? Step 6: Aggregate Data (MOST IMPORTANT STEP)

Set: ???? Aggregation = SUM

✅ This ensures:

All pods memory = ONE combined value

???? Step 7: Remove Splitting

Ensure: ???? No Split by anything (pod/container/etc.)

⚠️ If you see multiple lines → YOU DID IT WRONG

???? Step 8: Choose Visualization

Pick one:

✅ Single value tile (BEST for exam)

OR simple graph (no split)

???? Step 9: Set Timeframe

Top right of dashboard:

???? Set:

Last 30 minutes

???? Step 10: Save Dashboard

Click: ???? Save

Dynatrace allows muting/unmuting vulnerabilities with granular scope control , including:

Specific Process Group

Specific Management Zone

Specific CVE (vulnerability identifier)

These options allow precise control over how vulnerabilities are handled and displayed.

Options based on state (open/resolved) are not the criteria for muting configuration.

Dynatrace categorizes user types primarily into Real Users and Synthetic Users .

Real Users represent actual human users interacting with applications. Their behavior is captured through Real User Monitoring (RUM), which tracks real-time user interactions, performance, and experience.

Synthetic Users are simulated users generated by Synthetic Monitoring. These are automated scripts that mimic user behavior to test availability and performance proactively.

The terms “Robots” and “Human” are not official Dynatrace user type classifications in the platform. Dynatrace specifically uses the standardized categories of Real and Synthetic users for monitoring and analysis.

Agentless RUM enables Real User Monitoring without requiring OneAgent installation on the server. It works by injecting a JavaScript snippet into the web application, which captures user interactions and performance data directly from the browser.

This approach is useful when:

You do not have access to the server

Installing OneAgent is not possible

You still need frontend visibility

Other options do not apply:

Dynatrace Operator is for Kubernetes deployments

ActiveGate is used for routing and extending connectivity

Discovery mode still requires OneAgent installation

Dynatrace provides multiple methods to ingest OpenTelemetry data, each suited for different deployment scenarios:

Dynatrace ActiveGate API (Option B): ActiveGate serves as a central collection gateway to the Dynatrace backend, providing OTLP endpoints for OpenTelemetry data. It requires an access token for authentication and a secure connection using TLS. This method simplifies and centralizes network traffic and management.

Dynatrace SaaS API (Option C): The SaaS ingest API offers a straightforward approach to ingest OpenTelemetry data. Applications can be configured for standard OTLP export without the need for additional installed components or services. It also requires an access token and a secure TLS connection.

Dynatrace OneAgent (Option D): OneAgent provides a local-only endpoint for trace ingestion. This method offers automatic request enrichment and does not require explicit authentication. However, it only accepts traces, not metrics or logs, and is limited to localhost connections.

Incorrect Options:

Dynatrace RUM (Option A): Real User Monitoring (RUM) is designed to capture and analyze user interactions within web applications. It does not serve as a method to ingest OpenTelemetry data.

Dynatrace Operator (Option E): The Dynatrace Operator is a Kubernetes operator that automates the deployment and management of OneAgent in Kubernetes environments. While it facilitates monitoring within Kubernetes, it is not a direct method for ingesting OpenTelemetry data.

To achieve full visibility into database performance , Dynatrace requires a combination of deep monitoring, code-level tracing, and database-specific metrics:

OneAgent in Full-Stack mode on the database host enables deep process-level monitoring and visibility into database internals where supported

OneAgent on application servers provides code-level tracing , capturing database calls within distributed traces and linking them to application performance

Database Extensions provide detailed technology-specific metrics , such as query performance, buffer usage, and connections

Real User Monitoring focuses on end-user experience and does not directly provide database-level visibility.

Infrastructure-only mode limits visibility to host-level metrics and does not provide deep code-level or database insights.

Notebooks are the best tool in Dynatrace for retaining and reusing DQL query results .

They allow users to:

Store DQL queries

Keep query results for later analysis

Combine queries with text, documentation, and visualizations

Share insights across teams

Other options:

Dashboards are for visualization, not query retention

Data Explorer is for ad-hoc analysis

Reports are more static and not designed for iterative DQL workflows

The Failure Analysis page is the primary view for investigating high failure rates.

It provides:

Breakdown of errors

Failure patterns

Root cause indicators

This makes it the first place to investigate when failures increase.

The three pillars of observability are:

Metrics – numerical performance data

Logs – event-based records

Traces – end-to-end request tracking

These pillars provide the foundation for understanding system behavior.

Other options:

Automation is not a pillar

RUM is a capability built on top of these pillars

The Clouds App in Dynatrace provides a unified, single-pane view across multiple cloud providers (hyperscalers), such as AWS, Azure, and Google Cloud. It aggregates cloud services, resources, and their relationships into one centralized interface.

This capability allows users to:

Monitor multi-cloud environments in one place

Analyze dependencies across different cloud providers

Gain visibility into cloud services, costs, and performance

Other options do not serve this purpose:

Extensions v2 extend monitoring capabilities

RUM focuses on end-user experience

Kubernetes App focuses specifically on Kubernetes environments

The Dynatrace API can be used to dynamically retrieve the latest version of the RUM JavaScript snippet during build time. This ensures that the most up-to-date script is always injected into the application without manual updates.

Other options:

ActiveGate is for communication and routing

OpenKit is for custom apps

OneAgent is not used in agentless/manual injection

Dynatrace uses hexagon-style health tiles with green and red indicators to visualize the health status of monitored entities.

These are specifically used in:

Service health tiles – showing health of services

Application health tiles – showing overall application health

These tiles provide a quick visual overview of system health using color-coded hexagons.

Other options:

Synthetic monitor health uses different visualization styles

Web applications is not a tile type

Problems shows problem cards, not hexagon visualization