Skip to main content
This lesson demonstrates Datadog’s data visualization capabilities across metrics, logs, APM traces, and Kubernetes visibility. The walkthrough follows the Datadog left-side navigation to show how to inspect telemetry, manage tags to control metric cardinality, build queries, and create dashboards that support operational monitoring and FinOps goals.

​
Metrics overview

From the left panel, click Metrics to open the Metrics overview. The top section provides a platform-level snapshot of metric sources, the configurable processing pipeline, and an overview of ingested metrics (agents, integrations, API).
The image is a screenshot from Datadog's metrics overview page, showing a flowchart of how metrics flow through Datadog, with sections for metric sources, configurable processing, and available metrics. It includes data on active agents, cloud integrations, and API metrics.
This demo environment reports only standard metrics via the Datadog Agent. There are no cloud integrations or API-generated metrics in this account, and logs/APM are not generating metrics here. All ingested telemetry passes through Datadog’s backend processing pipeline where you can add processing steps or scripts to transform data before indexing.

​
Standard vs custom metrics

Standard metrics are typically collected by Datadog agents or integrations and usually do not incur additional per-metric costs. Custom metrics (user-created or high-cardinality metrics) can increase billing, so controlling which tags and metrics you emit is important for cost management and platform health.
Pay attention to tag cardinality: reducing unnecessary high-cardinality tags (for example, unique container IDs) helps control custom metric growth and platform costs.

​
Metrics by source

Scroll down to see a breakdown of metrics by source: Kubernetes, APM, profiling, CSM, and others. This view helps you identify where your metrics originate and prioritize optimizations (for example, convert high-cardinality custom metrics to aggregated forms).
The image shows a Datadog dashboard displaying metrics by source, with visual blocks representing "Other" at 13.89 and "APM" at 10.39, along with smaller segments for "Profiling" and "CSM".
Further options list additional metric sources (logs, APM, RUM, processes, events) and provide links to guidance for optimizing tag usage for analytics.
The image shows the Datadog Metrics Overview interface, highlighting options for generating metrics from various sources like logs, APM, and processes. There are navigation items on the left and options to configure tags for analytics optimization.

​
Metric tagging and cost management

Datadog alerts you to tag growth because many metrics are created with default tags. Excessive tag cardinality increases ingestion and indexing volume. Where appropriate, remove low-value tags (especially on custom metrics) and prefer higher-level aggregation tags like kube_namespace, kube_deployment, or service.
Before removing tags, verify Related Assets (dashboards, monitors, alerts) that depend on them — deleting tags can break visualizations and alerts that rely on those tag dimensions.

​
Metrics Summary

Click Summary in the left panel to list all metrics ingested within a chosen time window (this example uses the past two weeks). Selecting a metric reveals its type, unit, description, historical points, and associated tags.
The image shows a software interface displaying container metrics, including CPU usage details, metadata, and tag information. It includes options for editing metrics and configuring historical data points.
For example, the container.cpu.usage metric in this demo is a gauge measured in nanocores and labeled as container total CPU usage. The tags panel lists all tags attached to the metric — e.g., container_id indicates how many distinct container IDs reported during the selected interval (44 distinct IDs in this example). Clicking the tag count expands the list of values.
The image displays a data analytics dashboard, showcasing various container metrics such as CPU and memory usage, alongside Kubernetes-related data such as services and deployments.
If this were a custom metric, use Manage Tags to delete or rename tags to reduce cardinality. For standard metrics, many default tags may carry less cost but still require review before removal because other assets may depend on them. The Related Assets section helps find dashboards and monitors that reference the metric.
This image shows a Datadog Metrics Summary page displaying container CPU usage metrics and related configuration details. It includes information about metric types, historical metrics, and related dashboards.

​
Metrics Explorer

Open Explorer to build and preview metric queries interactively. Search for metrics like container.cpu.usage, set the desired time range (e.g., past month), and experiment with functions and groupings to understand behavior over time.
The image shows a Datadog Metrics Explorer interface displaying a graph of average system CPU usage over time, with a search for container CPU usage metrics.
Group by higher-level tags such as kube_deployment to compare CPU usage across deployments instead of individual containers. This produces cleaner, more actionable dashboards and reduces noise from high-cardinality dimensions.
The image shows a Datadog Metrics Explorer dashboard displaying a line graph of average container CPU usage over time, categorized by Kubernetes deployment.

​
Kubernetes metrics

Datadog collects standard Kubernetes metrics (pod counts, container restarts, node metrics, etc.). Use these metrics to evaluate cluster stability and resource utilization. Note that aggregation functions (avg, sum) change the displayed context — switching from average to sum reveals total counts across the cluster.
The image shows a Datadog Metrics Explorer interface displaying a line graph of Kubernetes container restarts over a period from July 5th to July 10th. The graph indicates a spike in restarts on July 6th.
Example metric query (Datadog’s metric query syntax combines metric names and aggregation functions): 
sum:kubernetes.containers.restarts(*)

​
Volume and cost monitoring

Monitor metric volume with the Volume Overview to track estimated indexed and ingested custom metrics over time. This helps teams spot spikes in metric creation and make targeted changes to avoid unexpected billing.
The image shows a Datadog dashboard displaying Volume Overview graphs for estimated indexed and ingested custom metrics, with filters and configuration options on the sidebar.

​
Logs

Open Logs Explorer, set a time range (for example, past 15 days), then review the timeline and log counts. Click a log to inspect raw content and the parsed fields available for filtering. Example log message from the timeline: 
[WARNING] No files matching import glob pattern: /etc/coredns/custom/*.server
The image is a screenshot of the Datadog Log Explorer interface, showing log details and filtering options within a web browser.
Use structured fields like container_name, kube_deployment, kube_namespace, and cluster_name to filter and isolate issues. Datadog’s search supports natural-language and AI-assisted query generation to speed up filter creation.

​
APM (Application Performance Monitoring)

Under APM → Services (Software Catalog) Datadog lists instrumented services. Select a service to view traffic, error rates, latency, and suggested SLOs or monitoring actions. You can also link to source code and commits (for example, GitHub) to improve traceability between telemetry and code changes.
The image shows a software management dashboard from a developer portal displaying setup guidance and telemetry recommendations for a Node.js application in a production environment, with status indicators for various services like monitors and error tracking.

​
Trace Explorer and flame graphs

Use Trace Explorer to view traces across a selected window. Clicking a trace shows spans, a flame graph (time spent per operation), and a waterfall view for parent/child relationships and latency breakdown.
The image shows a Datadog dashboard displaying APM traces for a Node.js application, with details on HTTP requests and execution time in a graphical and textual format.
The flame graph and span table expose middleware, routers, handlers, and downstream calls. For example, a GET /route2 trace shows spans with duration, HTTP attributes, and additional metadata.
The image is a screenshot of the Datadog application showing APM trace details for a GET /route2 request, including duration, HTTP request details, and span attributes.
The waterfall view is especially helpful to pinpoint slow downstream services or inefficient middleware chains.

​
Dashboards and Infrastructure

Dashboards consolidate metrics, logs, traces, and synthetics to provide a unified observability view. The Infrastructure section includes explorers like Kubernetes Explorer for cluster-level troubleshooting and capacity planning.
The image shows a Datadog APM (Application Performance Monitoring) interface displaying traces data with spans, latency breakdown, and a navigation menu on the left.

​
Kubernetes Explorer

Kubernetes Explorer delivers a consolidated view of workloads (Deployments, ReplicaSets, CronJobs), autoscaling status (HPA/VPA), CRDs, storage controllers (CSI), and networking policies. Use it to investigate pod health, HPA behavior, network issues, and resource utilization. If the cluster is offline, the explorer will display no data; when active it surfaces the telemetry you need for debugging and capacity decisions.

​
Quick reference — Telemetry types and common tasks

Telemetry TypeUse CaseQuick Action
MetricsResource utilization, trends, alertingUse Metrics Explorer and group by kube_deployment or service
LogsTroubleshooting application errors and contextFilter by kube_namespace, container_name, or text search
Traces (APM)Latency analysis and dependency mappingOpen Trace Explorer → view flame graph and waterfall
Kubernetes ExplorerCluster health and autoscaling visibilityInspect pods, HPA events, CSI, and network policies

​
Conclusion

What you learned in this lesson:
  • How to navigate the Metrics overview and the difference between standard and custom metrics.
  • Inspecting metric details, tags, and related assets in Metrics Summary.
  • Querying, grouping, and visualizing metrics in Metrics Explorer to reduce noise and improve dashboards.
  • Monitoring metric volume with Volume Overview to manage costs.
  • Using Logs Explorer to filter and troubleshoot application logs.
  • Navigating APM traces, flame graphs, and Trace Explorer to locate latency sources.
  • Leveraging Kubernetes Explorer for cluster-level visibility and capacity planning.
Explore these tools to design dashboards and alerts that meet your operational reliability and FinOps objectives.

Watch Video