Study guide

12.3 OpenTelemetry Ingestion, OpenPipeline & Dynatrace Workflows Automation

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.3 OpenTelemetry Ingestion, OpenPipeline & Dynatrace Workflows Automation

Key Takeaways Explain This Topic AI

Dynatrace natively ingests OpenTelemetry (OTel) traces, metrics, and logs via the standard OpenTelemetry Protocol (OTLP/HTTP and OTLP/gRPC) without requiring proprietary collector agents.

Dynatrace seamlessly merges OpenTelemetry spans with OneAgent auto-instrumentation using standard W3C Trace Context, generating unified, end-to-end PurePath transaction traces.

OpenPipeline provides real-time, stream-based data processing at ingress, enabling routing, dropping/filtering, data transformation, and PII masking before data is committed to Grail storage.

Dynatrace Workflows automate complex IT operations, SRE runbooks, and closed-loop auto-remediation through an event-driven visual workflow engine.

Workflows can be triggered automatically by Davis AI problem lifecycle events, cron schedules, DQL threshold queries, or external webhooks, orchestrating external tools like Ansible, Jira, Slack, and Kubernetes.

Last updated: September 2026

Modern enterprise IT is characterized by the coexistence of vendor-neutral open-source standards and high-performance commercial observability platforms. The Cloud Native Computing Foundation (CNCF) OpenTelemetry (OTel) framework has emerged as the global standard for vendor-neutral telemetry instrumentation. Dynatrace provides native, first-class support for OpenTelemetry ingestion, combining open data collection with the analytical power of the Grail data lakehouse , OpenPipeline streaming data governance, and Dynatrace Workflows for closed-loop autonomous remediation.

OpenTelemetry Architecture & Native Ingestion Pathways

OpenTelemetry standardizes the collection of three primary telemetry signals: Traces , Metrics , and Logs . Dynatrace supports the standard OpenTelemetry Protocol (OTLP) over both OTLP/HTTP (binary Protobuf or JSON) and OTLP/gRPC . +-----------------------------------------------------------------------------------------+

  • | OPENTELEMETRY INGESTION ARCHITECTURE |
  • +-----------------------------------------------------------------------------------------+
  • | |
  • | [Custom App (OTel SDK)] [Kubernetes Pod (OTel Collector)] [AWS Lambda (OTel Layer)]|
  • | \ | / |
  • | \ | / |
  • | +-------------------------+----------------------------+ |
  • | | |
  • | v (OTLP / gRPC or HTTP) |
  • | +--------------------------------------+ |
  • | | ENVIRONMENT ACTIVEGATE | |
  • | | • Ingress Proxy & Message Router | |
  • | | • Token Authentication Validation | |
  • | +--------------------------------------+ |
  • | | |
  • | v (HTTPS / TLS 443) |
  • | +--------------------------------------+ |
  • | | DYNATRACE PLATFORM | |
  • | | +--------------------------------+ | |
  • | | | OPENPIPELINE | | |
  • | | | Filter -> Mask -> Route | | |
  • | | +--------------------------------+ | |
  • | | | GRAIL LAKEHOUSE | | |
  • | | | Logs, Traces, Metrics | | |
  • | | +--------------------------------+ | |
  • | | | DAVIS AI ENGINE | | |
  • | | +--------------------------------+ | |
  • | | | DYNATRACE WORKFLOWS | | |
  • | +--+--------------------------------+--+ |
  • +-----------------------------------------------------------------------------------------+
  • Direct Ingestion Endpoints and API Tokens

Telemetry can be transmitted directly to Dynatrace SaaS or routed through a local Environment ActiveGate acting as a high-performance proxy. ActiveGate endpoints alleviate WAN bandwidth by bundling connections and avoiding direct public cloud access from private subnets.

  • Traces Endpoint: https://{your-activegate-or-environment}/api/v2/otlp/v1/traces
  • Metrics Endpoint: https://{your-activegate-or-environment}/api/v2/otlp/v1/metrics
  • Logs Endpoint: https://{your-activegate-or-environment}/api/v2/otlp/v1/logs

Authentication requires a Dynatrace API Token configured with specific, least-privilege token scopes:

openTelemetryTrace.ingest — Authorizes ingestion of OTLP traces.

metrics.ingest — Authorizes ingestion of OTLP and custom metrics.

logs.ingest — Authorizes ingestion of OTLP and structured log records.

Hybrid Distributed Tracing: OneAgent + OpenTelemetry Interoperability

A critical requirement in large enterprises is the ability to combine OneAgent automatic bytecode instrumentation with OpenTelemetry custom spans without creating disjointed traces. Dynatrace accomplishes this via native support for the W3C Trace Context specification ( traceparent and tracestate HTTP headers):

When a OneAgent-monitored Java service calls a downstream Go microservice instrumented with OpenTelemetry SDK, OneAgent injects standard W3C traceparent headers into the outgoing HTTP request.

The Go microservice extracts the W3C context, starts a child span, and transmits the span via OTLP to Dynatrace.

Dynatrace automatically correlates the OpenTelemetry span with the parent transaction using the shared 128-bit trace_id and 64-bit parent_span_id .

The result is a single, uninterrupted PurePath distributed trace spanning both proprietary OneAgent sensors and open-source OpenTelemetry spans.

OpenPipeline: Ingress Stream Processing and Data Governance

As telemetry volumes explode, organizations face mounting storage costs and compliance challenges from unmasked Personally Identifiable Information (PII). OpenPipeline is Dynatrace's high-throughput stream processing engine that operates directly at the data ingress boundary— before telemetry is committed to long-term Grail storage or evaluated by Davis AI.

Core Stages of OpenPipeline Execution

OpenPipeline intercepts incoming telemetry streams (logs, metrics, business events, traces) and processes records sequentially through defined pipeline stages: Incoming Stream ---> [ ROUTING ] ---> [ FILTERING ] ---> [ TRANSFORMATION ] ---> [ MASKING ] ---> [ STORAGE (GRAIL) ]

Routing: Inspects metadata (e.g., source host group, Kubernetes namespace, cloud account, log severity) and routes the record to dedicated processing pipelines or storage tables.

Filtering (Drop Rules): Discards low-value, high-volume telemetry at line rate. For example, dropping high-frequency HTTP 200 OK health-check access logs or verbose DEBUG log streams from non-production containers. Dropped records do not incur Grail storage costs or consume Davis Data Units (DDUs).

Transformation & Normalization: Parses unstructured text into structured JSON fields, normalizes non-standard attribute keys to match OpenTelemetry semantic conventions, and enriches records with contextual metadata (e.g., mapping IP addresses to corporate data centers).

Masking & Security Compliance: Identifies sensitive data patterns using regular expressions—such as credit card numbers (PCI-DSS), Social Security numbers, passwords, and authorization tokens—and permanently redacts or hashes them before persistence. Because masking occurs at stream ingress, sensitive data is never written to disk, guaranteeing strict GDPR, HIPAA, and SOC 2 compliance.

Dynatrace Workflows: Event-Driven Automation

Observability without automated action leaves organizations vulnerable to slow manual incident response. Dynatrace Workflows is an enterprise automation and orchestration engine built directly into the platform, providing visual canvas orchestration, low-code action blocks, and custom TypeScript/JavaScript execution tasks.

Workflow Trigger Mechanisms

Workflows are event-driven and can be activated through multiple trigger types:

Davis Problem Events: Fires automatically when Davis AI detects an anomaly, when a problem transitions states (e.g., opened, updated with new root cause, or resolved), or when specific severity thresholds are met.

Schedules (Time-Based / Cron): Executes periodically at defined intervals (e.g., running hourly capacity audits or daily compliance checks).

DQL Threshold Monitors: Evaluates a Dynatrace Query Language (DQL) query against Grail storage and triggers when query output breaches a predefined threshold.

On-Demand & Webhooks: Triggered manually by operators via the Dynatrace console or invoked externally by CI/CD pipelines and external webhooks.

Integrated Ecosystem Connectors

Dynatrace Workflows feature deep native connectors across modern IT enterprise ecosystems:

Incident Management & ChatOps: ServiceNow (creating/updating incidents and change requests), Jira, PagerDuty, Slack, and Microsoft Teams.

Configuration Management & Infrastructure: Ansible Automation Platform (launching automation controller job templates), Terraform Cloud, AWS Systems Manager, and Kubernetes (executing pod restarts or scaling deployments).

Custom Logic & Cloud Functions: Executing custom JavaScript/TypeScript code within secure platform sandboxes, invoking AWS Lambda, Azure Functions, or triggering generic HTTP/REST webhooks.

Closed-Loop Autonomous Remediation Architecture

A primary goal of Site Reliability Engineering is achieving closed-loop self-healing —detecting an incident, identifying the root cause, applying remediation, and verifying recovery without human intervention. +-----------------------------------------------------------------------------------------+

  • | CLOSED-LOOP AUTO-REMEDIATION WORKFLOW LIFECYCLE |
  • +-----------------------------------------------------------------------------------------+
  • | |
  • | 1. DAVIS AI PROBLEM DETECTION |
  • | • Davis detects response time degradation on 'Payment-Service'. |
  • | • Root cause identified: Memory leak causing GC thrashing on Container Pod A. |
  • | |
  • | 2. WORKFLOW TRIGGER ACTIVATION |
  • | • Event trigger matches problem category: 'RESOURCE_SATURATION'. |
  • | • Workflow initializes with execution context (affected Entity ID, Problem ID). |
  • | |
  • | 3. DIAGNOSTIC COLLECTION & ENRICHMENT |
  • | • Task executes DQL query to extract heap dump summaries and container logs. |
  • | • Creates a high-priority incident in ServiceNow containing diagnostic telemetry. |
  • | |
  • | 4. AUTOMATED REMEDIATION ACTION |
  • | • Workflow invokes an Ansible Automation controller job via REST API. |
  • | • Ansible triggers a graceful rolling restart of the saturated microservice pod. |
  • | |
  • | 5. VERIFICATION & AUDIT CLOSURE |
  • | • Workflow pauses (sleep timer) and queries Davis problem status via DQL. |
  • | • If Davis marks the problem RESOLVED, Workflow posts resolution comment to Jira, |
  • | notifies Slack #sre-ops, and closes the ServiceNow ticket autonomously. |
  • +-----------------------------------------------------------------------------------------+
  • Technology Comparison Matrix

Capability Dimension OpenTelemetry (OTel) Dynatrace OneAgent Full-Stack OpenPipeline Ingress Processing Dynatrace Workflows

Core Role Vendor-neutral telemetry instrumentation standard Automated full-stack discovery, bytecode injection, & topology mapping Real-time stream filtering, routing, and PII masking at ingress Event-driven orchestration, incident response, and auto-remediation

Deployment Model Application SDK or OTel Collector daemon Single binary daemon per host / container node Ingress service executing on Dynatrace cluster/ActiveGate Cloud-native workflow engine executing inside Dynatrace

Code Modification Requires code instrumentation or agent configuration Zero code modification; fully automatic injection Zero code modification; rule-based configuration Zero code modification; visual drag-and-drop or JavaScript

Data Governance Governed at collector level Automatic sensitive data masking at agent Centralized stream-level drop, transform, and regex masking Enforces remediation policies and audit tracking

Integration Points Standard OTLP (gRPC/HTTP) Proprietary TLS encrypted stream over port 9999/443 Grail Lakehouse storage tables ServiceNow, Jira, Slack, Ansible, K8s, HTTP APIs

Loading diagram... OpenTelemetry, OpenPipeline Stream Processing & Dynatrace Workflows Architecture