Study guide

16.1 Metrics on Grail: Built-in Metrics, Granularity & Retention

Dynatrace Certified Associate Exam

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Platform Overview, Deployment Models & Architecture

1.1 Dynatrace Platform Capabilities, Web UI Navigation & the Dynatrace Hub 1.2 SaaS vs. Dynatrace Managed Architecture & Security 1.3 Core Telemetry Components: OneAgent, ActiveGate & Grail Lakehouse 1.4 Licensing Models: Dynatrace Platform Subscription (DPS) & Davis Data Units (DDUs)

2 Chapter 2: ActiveGate Architecture & Network Topologies

2.1 ActiveGate Types: Environment vs. Cluster ActiveGates 2.2 ActiveGate Capabilities: Proxying, Private Synthetic, Cloud Integrations & Extensions 2.3 Network Zones, Multi-DC Routing & Firewall Traversal

3 Chapter 3: OneAgent Deployment, Configuration & Management

3.1 OneAgent Architecture, Components & Automatic Injection 3.2 Host Installation on Linux, Windows & Containerized Hosts 3.3 Cloud-Native Deployment: Dynatrace Operator on Kubernetes & OpenShift 3.4 Kubernetes Observability: Clusters, Nodes, Namespaces, Workloads & Events

4 Chapter 4: Monitoring Modes, Process Groups & Infrastructure Observability

4.1 Monitoring Modes: Full-Stack vs. Infrastructure-Only vs. Discovery 4.2 Process Groups, Process Instances & Custom Process Group Detection Rules 4.3 Host Groups, Host Naming Rules & Environmental Metadata Extraction 4.4 Infrastructure & Operations: Host Health, Disk, Network & Availability Analysis 4.5 Database Observability: The Databases App, Connection Pools & Storage Latency

5 Chapter 5: Smartscape Topology & Service Flow

5.1 The 5-Layer Smartscape Topology: Datacenter to Application 5.2 Service Detection: Web Services, Background Tasks & Custom Services 5.3 Service Flow, Backtrace Analysis & Horizontal/Vertical Dependency Mapping

6 Chapter 6: PurePath Distributed Tracing & Code-Level Diagnostics

6.1 PurePath Architecture, Distributed Tracing & Request Context Propagation 6.2 Method Hotspots, CPU Profiling & Memory Allocation Thread Analysis 6.3 Database Service Diagnostics, Slow Queries & Exception Analysis

7 Chapter 7: Davis AI Engine, Baselining & Causation

7.1 Davis Deterministic Causation Engine vs. Pure Correlation 7.2 Automated Dynamic Baselining, Percentiles & Traffic Seasonality 7.3 Event Ingestion, Event Types & Event Hierarchy in Problem Evolution

8 Chapter 8: Problem Lifecycle, Root Cause Analysis & Alerting

8.1 Problem Lifecycle, Severity Categories & Root Cause Cards 8.2 Alerting Profiles, Delay Filters & Management Zone Routing 8.3 Problem Notification Integrations: Webhooks, Slack, ServiceNow & ITSM

9 Chapter 9: Digital Experience Monitoring: Synthetic Monitoring

9.1 Synthetic Monitors: HTTP, Single-Step Browser & Multi-Step Clickpaths 9.2 Private Synthetic Locations, ActiveGate Engines & Credential Vault 9.3 Outage Detection, Performance Baselining & Maintenance Suppression

10 Chapter 10: Digital Experience Monitoring: Real User Monitoring (RUM)

10.1 RUM Architecture, OneAgent Script Injection & Mobile/OpenKit Telemetry 10.2 User Actions: Load vs. XHR/Fetch Actions, Visually Complete & Speed Index 10.3 Apdex Performance Ratings, User Sessions & Session Replay Masking

11 Chapter 11: Log Management and Analytics on Grail with DQL

11.1 Log Management on Grail: Storage, Ingestion Pipelines & Log Masking 11.2 Dynatrace Query Language (DQL): Fetch, Filter, Fields & String Operations 11.3 DQL Aggregations: Summarize, MakeTimeseries, Sorting & Visualizations

12 Chapter 12: Platform Governance, OpenTelemetry & Automation

12.1 Management Zones: Scoping Observability, Dashboards & Access Control 12.2 Tagging Strategies: Automated Rule-Based Tags, Manual Tags & AWS/K8s Metadata 12.3 OpenTelemetry Ingestion, OpenPipeline & Dynatrace Workflows Automation

13 Chapter 13: Cloud Integrations & Agentless Infrastructure Ingestion

13.1 AWS, Azure & Google Cloud Integrations 13.2 VMware vSphere, Extensions & Other Agentless Ingestion Paths

14 Chapter 14: Business Analytics & Business Events

14.1 Business Events: Capture, Ingestion & the bizevents Grail Table 14.2 Business Analytics: Connecting Performance to Revenue, Conversion & KPIs

15 Chapter 15: Notebooks, Dashboards & Data Visualization

15.1 Notebooks: Section-Based Investigation & Shareable Analysis 15.2 Dashboards: Tiles, Variables, Segments & Continuous Monitoring 15.3 Choosing Visualizations: Data Explorer, Chart Types & Metric Selection

16 Chapter 16: Reporting, Metrics & User Behavior Analysis

16.1 Metrics on Grail: Built-in Metrics, Granularity & Retention 16.2 Dashboard Reports, Subscriptions & Exporting Data via APIs 16.3 User Behavior Analysis: Bounce Rate, Landing & Exit Pages, Conversion Goals 16.4 Session Segmentation, User Journeys & Funnel Drop-Off Analysis

17 Chapter 17: Security, Vulnerability Analytics & Application Protection

17.1 Platform Security: Data Privacy, Encryption & Access Control 17.2 Third-Party Vulnerabilities, the Davis Security Score & Security Advisor 17.3 Code-Level Vulnerabilities, Attacks & Runtime Application Protection 17.4 Security Investigator, Notifications & the Remediation Workflow

16.1 Metrics on Grail: Built-in Metrics, Granularity & Retention

Key Takeaways Explain This Topic AI

Reporting and Analysis is a separately scored Associate exam topic covering metrics, reports, APIs, and user behavior analysis.

Metrics powered by Grail keep 1-minute granularity across the entire history — 15 months by default, configurable per bucket to 10 years — while Metrics Classic is fixed at 5 years and coarsens to 1-day granularity beyond 400 days.

Grail-based distributed tracing retention is configurable from 10 days to 10 years, whereas Distributed Traces Classic retains 10 days.

The default retention for user events and user sessions is 35 days, the same default as logs in the default_logs bucket.

Retention differences explain why a long-range capacity trend must be answered with metrics rather than with sessions or traces.

Last updated: September 2026

Reporting and Analysis is its own scored line on the Dynatrace Associate exam score report, and it is broader than it sounds: it covers metrics, dashboard reports, data export through APIs, user behaviour analysis, and session segmentation. This chapter covers all four. We start with metrics, because every report is ultimately built on them.

Where Metrics Come From

Dynatrace metrics arrive from four places:

Automatically from OneAgent — host CPU, memory, disk, network; process metrics; service response time, failure rate, and throughput. Nothing is configured.

From cloud integrations and extensions — CloudWatch, Azure Monitor, SNMP, JMX, Prometheus (Chapter 13).

Calculated — metrics derived from request attributes, logs, or business events.

Custom-ingested — pushed via the metric ingest API, metered at 0.001 DDU per data point (Section 1.4).

The first category is the one to emphasize on the exam: a very large fraction of what a candidate might assume needs configuration is produced automatically by OneAgent.

Granularity and Retention — The Numbers That Get Tested

Retention is where exam questions become concrete, because different data types keep data for very different periods.

Data type Retention

Metrics powered by Grail 1-minute granularity across the entire history ; 15 months (462 days) included by default, configurable per bucket up to 10 years (3,657 days)

  • Metrics Classic 5 years, not configurable , with granularity that coarsens in fixed tiers (see below)
  • Logs (Grail) Default 35 days in default_logs ; buckets configurable up to 10 years
  • Distributed tracing (Grail) Configurable from 10 days to 10 years
  • Distributed traces Classic 10 days
  • User events and user sessions Default 35 days

Metrics Classic downsamples on a published schedule, and the tiers are worth memorizing because scenarios are built directly on them:

  • Age of the data Interval granularity
  • 0–14 days 1 minute
  • 14–28 days 5 minutes
  • 28–400 days 1 hour
  • 400 days – 5 years 1 day

Two consequences follow, and both appear as scenarios:

1. Long-range questions must be answered with metrics. "Show me how host memory utilization has trended over the past two years" is answerable from Metrics Classic history — at day granularity — but is not answerable from sessions or traces, which are long gone. A question offering "query the user sessions from eighteen months ago" is testing this.

2. Granularity coarsens with age. The 5-year figure for Metrics Classic does not mean five years of minute-by-minute detail. By the time data is a year old it is stored at a coarse interval suitable for trend analysis, not for incident forensics. Answers claiming "detailed per-minute data for five years" overstate what is retained.

Grail Metrics and Metrics Classic Differ by More Than Retention

  • Metrics powered by Grail Metrics Classic
  • Query language DQL , via timeseries Metric selector , via Metrics API v2
  • Granularity 1 minute over the entire history Tiered, coarsening with age
  • Retention 15 months by default, up to 10 years per bucket 5 years, fixed
  • Query limit 500 million data points 20 million data points
  • Dimensions Effectively limitless, excluding highly volatile ones Fixed cardinality pools

The practical reading: a question that asks for minute-level detail two years back is answerable only on Metrics powered by Grail with an extended bucket retention. Metrics Classic still holds two-year-old data, but by then it is stored at one point per day.

Reading Metrics with DQL

Grail metrics are queried with the timeseries command, which returns a series rather than a record list: timeseries mem = avg(dt.host.memory.usage),

  • by: { dt.entity.host },
  • from: now() - 30d,
  • interval: 1h

Compare that to fetch , which returns records (logs, spans, business events). Knowing which command applies to which data type is a reasonable exam expectation: timeseries for metrics, fetch for records.

Metrics can also be created from records. A DQL query over logs or business events can be converted into a metric so that it becomes chartable, alertable, and long-lived — which is how a business KPI (Chapter 14) becomes something Davis can baseline.

Metric Semantics

Dynatrace metric keys follow a semantic dictionary — a governed naming convention such as dt.host.cpu.usage or dt.service.request.response_time . Two practical consequences:

Built-in metric keys are stable and portable. A dashboard built on dt.host.cpu.usage works in any tenant.

Custom metrics should follow the same convention. Ad-hoc names such as myteam_cpu_thing make estate-wide queries impossible.

The dt. prefix is reserved. Grail reserves dt. for Dynatrace-controlled metrics and fields. Metric data ingested under a dt. key is dropped , and dimensions ingested with a dt. prefix are ignored . Custom metrics imitate the dotted namespace style — acme.checkout.orders.count — but never borrow the prefix itself.

Metrics also carry dimensions — the labels you split and filter by (host, service, region, endpoint). Dimensions are what make a metric analytically useful and simultaneously what drives its cost, since each unique dimension combination is a separate series.

Cardinality and the One-Minute Bucket

Two ingest rules decide what a dimension choice actually costs:

Cardinality limits are enforced, and enforcement means rejection. Metrics Classic caps each metric at 1 million dimension tuples , evaluated over a 30-day sliding window . Once the cap is reached, data points carrying new, previously unseen tuples are simply rejected — the metric does not fail loudly, it just stops accepting new series. The classic self-inflicted wound is a dimension that changes on every write: a measured_at epoch timestamp, which merely duplicates information the data point already carries, reaches a million tuples in roughly 11 days .

A series is billed at most once per minute. Measurements arriving faster than once a minute are aggregated into fixed one-minute buckets , so no time series is billed for more than one data point per minute. At 0.001 DDU per data point, that sets a ceiling of 525.6 DDUs per series per year (Section 1.4) however aggressively an exporter pushes.

The planning corollary is worth stating plainly: metric cost is driven by cardinality , not by scrape frequency. Doubling the push rate above one-per-minute changes nothing, while adding one dimension with a thousand distinct values multiplies the series count by a thousand.

Choosing the Right Data Type for a Reporting Question

Work it from the retention and shape of the question:

  • The question Right data type Why
  • "How has CPU trended over 18 months?" Metric Only metrics live that long
  • "What exact error text did this request produce?" Log Metrics have no message content
  • "What did this individual request do internally?" Trace / PurePath Metrics are aggregates
  • "Exactly how many orders completed yesterday?" Business event Not sampled, structured, exact
  • "Which pages do users leave from?" RUM / session data Behavioural, 35-day default

The recurring exam trap is proposing a metric for a question that needs a record — metrics cannot tell you which customer or what message, only how many and how fast.

Loading diagram... Data Type Retention Boundaries and What Each Can Answer