Study guide
12.2 Tagging Strategies: Automated Rule-Based Tags, Manual Tags & AWS/K8s Metadata
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
12.2 Tagging Strategies: Automated Rule-Based Tags, Manual Tags & AWS/K8s Metadata
Key Takeaways Explain This Topic AI
Dynatrace provides three primary tagging mechanisms: manual tags applied via UI/API, automated rule-based tags evaluated dynamically on the cluster, and automatically imported cloud and container metadata.
Automated rule-based tags dynamically categorize entities at runtime based on entity names, process arguments, environment variables, and regular expression capture groups without requiring agent restarts.
OneAgent automatically discovers and ingests host attributes, Kubernetes labels/annotations, and hyperscaler metadata (AWS EC2 tags, Azure resource tags, GCP labels) directly into entity properties.
Agent-side environment configurations like DT_TAGS and custom.properties inject static host-level metadata at startup, which can serve as input conditions for cluster-side automated tagging rules.
Standardized key-value tagging schemas (e.g., environment:prod, owner:payments, tier:backend) are vital for scalable governance, driving Management Zones, Davis AI problem clustering, and Service Level Objectives (SLOs).
Last updated: September 2026
In dynamic enterprise ecosystems characterized by ephemeral containers, auto-scaling microservices, and serverless compute, static configuration is obsolete. Infrastructure and services are continuously provisioned and decommissioned. To maintain control, observability platforms require robust metadata and tagging strategies . In Dynatrace, tags and metadata provide the foundational intelligence that powers automated governance, scoping Management Zones, routing Davis AI alerting profiles, filtering Service Level Objectives (SLOs), and structuring analytics queries in Dynatrace Query Language (DQL).
Taxonomy of Dynatrace Tags: Mechanisms and Lifecycles
Dynatrace distinguishes between several distinct types of tags and metadata, each possessing unique lifecycle characteristics, evaluation engines, and operational purposes. +-----------------------------------------------------------------------------------------+
- | DYNATRACE TAGGING TAXONOMY |
- +-----------------------------------------------------------------------------------------+
- | 1. MANUAL TAGS |
- | • Applied via Web UI or Monitored Entities API v2. |
- | • Statically bound to a specific internal entity ID (e.g., HOST-4B3A82C1). |
- | • Destroyed when the entity is decommissioned; does NOT survive dynamic recreation. |
- +-----------------------------------------------------------------------------------------+
- | 2. AUTOMATED RULE-BASED TAGS |
- | • Defined globally in Settings > Tags > Automatically applied tags. |
- | • Evaluated dynamically by the Dynatrace server cluster against entity properties. |
- | • Instantaneous, retroactive, and supports regular expression value extraction. |
- +-----------------------------------------------------------------------------------------+
- | 3. INGESTED CLOUD & CONTAINER METADATA |
- | • Discovered natively via OneAgent or ActiveGate Cloud Integrations. |
- | • Ingests Kubernetes pod/namespace labels, AWS EC2 tags, Azure tags, and GCP labels. |
- | • Stored as read-only entity properties; ideal trigger sources for automated rules. |
- +-----------------------------------------------------------------------------------------+
- | 4. AGENT-LEVEL ENVIRONMENT INJECTIONS (DT_TAGS & custom.properties) |
- | • Configured directly on compute hosts via configuration management (Ansible/Chef). |
- | • Statically injected into OneAgent during process initialization. |
- +-----------------------------------------------------------------------------------------+
- Why Manual Tags Fail at Enterprise Scale
Manual tags are added by a user clicking "Add tag" in the Dynatrace UI or posting to /api/v2/entities/{entityId} . While convenient for quick ad-hoc troubleshooting, manual tags are an anti-pattern for enterprise production governance :
They cannot adapt to auto-scaling events: when an auto-scaling group provisions ten new virtual machines, the new instances lack the manual tags.
When a Kubernetes pod restarts or rolls to a new deployment replica, its internal entity ID changes, severing any manual tags attached to the previous instance.
They introduce configuration drift and human error, undermining automated governance pipelines.
Automated Rule-Based Tags: Architecture and Mechanics
Automated tagging rules are configured centrally in the Dynatrace web console ( Settings > Tags > Automatically applied tags ) or through the Configuration API ( /api/config/v1/autoTags ). Unlike manual tags, automated rules do not bind to static entity IDs; they are continuous evaluation rules executed cluster-side .
Evaluation Engine and Propagation
When OneAgent registers a new entity (host, process group, or service), or when entity metadata updates, the Dynatrace rules engine evaluates all configured auto-tag rules in real time:
Target Entity Selection: The rule specifies which entity type it evaluates (e.g., Hosts, Process Groups, Services, Applications).
Rule Conditions: Conditions evaluate incoming properties using comparison operators ( equals , contains , begins with , ends with , regex match , exists ).
Tag Assignment: If all conditions match, the specified tag is attached to the entity.
Topological Propagation: Rules can optionally propagate tags across Smartscape boundaries (e.g., from Process Groups down to running Services, or from Hosts to Process Groups).
Dynamic Value Extraction Using Regular Expression Capture Groups
A critical feature of automated tagging rules is the ability to dynamically extract tag values from runtime properties rather than hardcoding static strings. This is accomplished using regular expression capture groups ( {1} , {2} ).
Consider an enterprise where Java microservices are launched with a standard command-line argument defining environment and tier: -Dapp.descriptor=billing-prod-east .
An administrator can configure an automated tag rule as follows:
- Tag Key: Deployment
- Target Entity: Process Groups
- Condition: Process execution command line contains regex: -Dapp\.descriptor=([a-z]+)-([a-z]+)-([a-z]+)
- Tag Value Definition: {1}:{2}
- Resulting Tag Attached: Deployment:billing:prod
This single dynamic rule automatically extracts and assigns precise, standardized key-value tags across thousands of diverse applications without requiring custom code or manual intervention.
Native Cloud and Container Metadata Ingestion
Modern cloud-native platforms already possess rich metadata frameworks. Dynatrace automatically discovers and leverages these existing metadata streams, eliminating redundant data entry.
Kubernetes and OpenShift Metadata Discovery
OneAgent natively communicates with the local node kubelet and Kubernetes API server. It automatically captures pod, node, and namespace metadata and attaches them as read-only entity properties:
Pod Labels: Captured as [Kubernetes]pod.label.* (e.g., app.kubernetes.io/name , app.kubernetes.io/version , release ).
Namespace Annotations & Labels: Captured as [Kubernetes]namespace.label.* .
Workload Metadata: Workload name, controller kind (Deployment, StatefulSet, DaemonSet), container image repository, and container image tag.
These properties are immediately accessible within automated tagging rule conditions. For example, an automated rule can state: "If [Kubernetes]pod.label.app exists, apply tag Service:{[Kubernetes]pod.label.app} " .
Hyperscaler Cloud Tag Ingestion (AWS, Azure, GCP)
Through ActiveGate-based cloud platform integrations, Dynatrace continuously polls cloud APIs to enrich monitored entities with cloud-native tags:
Amazon Web Services (AWS): Discovers AWS EC2 tags, RDS tags, Auto Scaling Group tags, and Lambda tags. Read-only properties appear in Dynatrace with the prefix [AWS]TagKey .
Microsoft Azure: Discovers Azure Resource Manager (ARM) tags across VMs, App Services, and Azure SQL instances.
Google Cloud Platform (GCP): Captures GCP labels across Compute Engine instances and Google Kubernetes Engine (GKE) clusters.
Agent-Side Host Configuration: DT_TAGS, custom.properties, and hostautotag.conf
In scenarios where entities must carry local metadata established by infrastructure automation tools (e.g., Terraform, Ansible, Puppet, Cloud-Init) before communicating with the Dynatrace cluster, OneAgent provides local configuration hooks.
Configuration Mechanisms Comparison
Mechanism Implementation Location Syntax / Format Operational Characteristics
DT_TAGS Environment Variable System or process environment variable export DT_TAGS="Owner=FinOps Tier=Backend" Evaluated on process startup. Tags appear on the host entity as static agent tags. Space-separated key=value or string format.
custom.properties /var/lib/dynatrace/oneagent/agent/config/custom.properties [CustomProperties] ; DataCenter = us-east-dc1 ; CostCenter = CC-8492 Ingests metadata as host properties (not direct tags). Highly recommended: serves as clean property input for cluster-side automated tagging rules.
hostautotag.conf /var/lib/dynatrace/oneagent/agent/config/hostautotag.conf Plain text strings, one tag per line (e.g., PCI_Enclave ) Injects tags directly into the host entity at OneAgent startup. Requires file write access during host provisioning.
Best Practice Recommendation: Prefer using custom.properties over DT_TAGS . Defining custom properties allows infrastructure teams to publish clean metadata keys ( DataCenter , Owner , Environment ) without cluttering the UI with unmanaged static tags. The Dynatrace administrator can then build centralized, automated rule-based tags that evaluate those custom properties.
Tagging Strategy Evaluation Matrix
Evaluation Dimension Manual UI / API Tags Automated Rule-Based Tags Ingested Cloud / K8s Metadata Agent Environment ( DT_TAGS )
Configuration Location Web UI / REST API Centralized Dynatrace Settings Cloud Provider / K8s Manifests Local Host OS Filesystem
Dynamic Auto-Scaling Fails (Requires post-launch API script) Instantaneous & Automated Instantaneous & Automated Automated (if baked into Cloud-Init/AMI)
Retroactive Application None (Affects single target entity ID) Yes (Instantly tags historical entities) None (Tied to provider entity) None (Requires agent restart)
Regex Value Extraction Unsupported Fully supported ( {1} , {2} ) Unsupported Unsupported
Maintenance Overhead Unsustainable at enterprise scale Extremely low (Set once globally) Zero (Inherits existing DevOps labels) Moderate (Requires OS config management)
Recommended Use Case Ad-hoc debugging / incident annotations Enterprise governance, MZ, and SLO routing Cloud-native microservices & K8s Legacy bare-metal server provisioning
Enterprise Tagging Best Practices: The Key-Value Pattern
To prevent tag pollution and ensure consistency across large organizations, enterprises must enforce a strict Key-Value tagging convention ( key:value ). Single-string tags (e.g., production , java , linux ) create ambiguity and cannot be queried efficiently.
Standardized Enterprise Taxonomy Schema
env:<stage> — Environment lifecycle stage ( env:prod , env:staging , env:dev ).
owner:<team> — Responsible engineering team ( owner:payments-sre , owner:order-fulfillment ).
service:<name> — Canonical service identifier ( service:billing-api , service:catalog-service ).
tier:<architecture> — Architectural tier ( tier:frontend , tier:backend , tier:database ).
compliance:<standard> — Regulatory compliance requirement ( compliance:pci-dss , compliance:hipaa ).
Standardized key-value tags allow administrators to define universal Management Zones (e.g., matching owner:payments-sre ), universal Alerting Profiles, and multi-dimensional SLO charts that dynamically populate without touching platform settings when new microservices deploy.