OpenTelemetry for Observability: The Complete Course

Windows users install an Ubuntu environment from the Microsoft Store, enable WSL, and work inside a Linux-like VM with Windows–Linux file system interoperability, including using explorer.exe to access Windows folders.

Explore Windows Subsystem for Linux features to seamlessly share files between Windows and Ubuntu, connect via VS Code, and run Linux commands from a Windows terminal.

Navigate the course codebase to access app-versions, front-end and worker projects, and labs, and learn to set up environments and install dependencies for instrumenting applications with compose and Kubernetes resources.

Explore the foundations of observability and how metrics, logs, and traces provide visibility, including histograms with percentiles, trace IDs, spans, SLIs, SLOs, SLAs, the four golden signals, and error budgets.

Explore observability as understanding a distributed system's behavior through external signals, learn the difference from monitoring, and discover how instrumentation reveals root causes across microservices.

Explore metrics as quantitative measurements that reveal how many, how fast, and how much a system performs, with counters, gauges, and histograms capturing latency and distribution.

Explore how histograms capture distributions with buckets and counts, using latency as an example. Interpret percentiles (p95, p99, p99.9) to understand outliers and user experience.

Explore how logs capture discrete events with raw details, compare human readable and machine readable (structured) logs, and learn log levels from debug to fatal for observability.

Explore traces and spans to map a complete request journey across services, tracking the trace ID, attributes, and parent span IDs, including external calls like the Stripe API.

Combine metrics, logs, and traces to understand system health and locate failures quickly. Use metrics for alerts and capacity planning, traces to pinpoint origins, and logs for detailed context.

Selects and measures carefully chosen, user-facing service level indicators to quantify availability and latency, ensuring dashboards reflect the complete user experience.

Define service level objectives (SLOs) as internal targets for SLIs, such as availability or latency, forming an internal commitment to service quality. They are not external SLAs.

Define service level agreements as contractual commitments that set external expectations while aligning with internal SLOs and SLIs, using buffers to avoid breaching customers' contracts.

Explore error budgets and risk management in observability, linking SLIs and SLOs to outages, downtime calculations, and when to push or pause risky deployments for reliability.

Explore the four golden signals—latency, traffic, errors, and saturation—and learn to measure response time, percentiles, demand, failure rates, and resource utilization to assess service health.

Set up the OpenTelemetry observability stack with docker and kubernetes, deploy Prometheus, Loki, Tempo, and Grafana, and trace telemetry flow from the app to Grafana through the backends.

Prometheus is a pull-based time-series database for metrics, scraped from services with labels. Use PromQL for rates, aggregations, and percentiles, and feed Grafana via the OpenTelemetry collector.

Deploy Prometheus with Docker Compose to explore metrics, configure Prometheus, and run basic PromQL queries in an observability stack. Create a root-compose.yaml to orchestrate services and verify targets.

Configure a Prometheus lab by creating Prometheus.yaml with schema validation, set a 15-second scrape interval, define targets, and set up a compose observability stack with persistent storage and port mapping.

Launch and verify Prometheus with Docker Compose, exploring observability stacks, Prometheus UI, and key metrics such as scrape duration and HTTP requests.

Deploy Loki locally and configure it similar to Prometheus, including ingestor and storage settings, set up docker-compose, add Loki as a Prometheus scrape target, and verify metrics.

Deploy Loki locally using docker compose by creating LokiConfig.yaml and extending Compose.observability.yaml. Verify readiness, inspect metrics, and prepare Prometheus to scrape Loki's components.

Connect Loki to Prometheus by adding a Loki scraping target in docker-compose, restart Prometheus, and verify Loki is healthy and actively scraped for metrics.

Explore Loki metrics in PromQL by examining the up-query, log ingestion rate, and rate calculations over time, including how scraping every 15 seconds yields a time-matrix of values.

Explore Tempo, a tracing backend that stores traces cost-effectively at scale. Indexing trace IDs and labels, compressing span contents, and enabling TraceQL queries with OpenTelemetry context propagation.

Deploy Tempo to your observability stack by configuring Tempo to receive traces via OpenTelemetry protocol over gRPC and HTTP, and extend the observability compose to run Tempo with Docker Compose.

Create Tempo-config.yaml and add Tempo to the observability compose, configure bind mounts and data volumes, then start containers and verify metrics and ready endpoints with Prometheus scraping.

Deploy Grafana as the visualization layer, and configure data sources for Prometheus, Loki, and Tempo. Start the Grafana service with Docker Compose, verify dashboards, and explore Prometheus metrics.

Deploy grafana by creating grafana-datasources.yaml, updating the observability compose, and validating Grafana, Prometheus, Loki, and Tempo data sources through docker-compose and the Grafana dashboard.

Deploy a multi-service translation app to observe end-to-end workflows with OpenTelemetry. Configure a TypeScript front-end, Python worker, and Redis queue with server-sent events for real-time updates.

Deploy a translation app locally using compose.app.yaml and a Redis-backed queue, with front end and worker on port 3001. Observe job handling and results flow for open telemetry and observability.

Explore a full-stack architecture for a translation app. OpenTelemetry collects metrics, logs, and traces from a front-end, redis queue, and Python worker, feeding Prometheus, Tempo, and Loki for Grafana visualization.

Explore the fundamentals and motivation of OpenTelemetry, and how APIs, SDKs, automatic and manual instrumentation, the collector, and semantic conventions enable out-of-the-box metrics and standardized telemetry.

OpenTelemetry offers a vendor-neutral observability framework to generate traces, metrics, and logs from your code. Instrument once and switch backends with API, SDKs, automatic instrumentation, and the collector.

Explore the OpenTelemetry APIs and SDKs, distinguishing stable interfaces from evolving implementations, and learn how APIs define spans and metrics while SDKs implement them, including batching, sampling, and exporters.

Learn how automatic instrumentation in OpenTelemetry provides telemetry for popular frameworks, then extend with manual instrumentation to add business context—spans, attributes, and metrics—enhancing observability for your applications.

Discover the OpenTelemetry collector, a vendor-agnostic data pipeline with receivers, processors, and exporters, deployable as agent or gateway to route, transform, and export telemetry to multiple backends.

Set up a local development environment for OpenTelemetry observability by migrating to development and production docker compose files with hot reloading for front-end and worker services.

Set up development and production docker compose files by duplicating compose.yaml into compose.prod.yaml and compose.dev.yaml, decoupling images from app configuration, and validating with docker compose up and hot reloading.

Explore how the OpenTelemetry collector centralizes telemetry by using receivers, pipelines, and exporters to forward data to backends like Prometheus, tempo, and Loki.

Deploy the OpenTelemetry Collector in a hands-on lab, building a configuration with OTLP receivers for traces, metrics, and logs, and configuring processors and exporters (Tempo, Prometheus, Loki) in Docker Compose.

Test and monitor the OpenTelemetry Collector by sending traces with a curl post, then verify in Tempo and inspect metrics in Prometheus via Grafana queries.

Run a hands-on lab to generate five traces with an AI companion, verify end-to-end data flow from OpenTelemetry Collector to Tempo via Grafana, and note metrics export limitations.

Expose internal OpenTelemetry collector metrics by adding a Prometheus telemetry endpoint, configure a scrape job, and validate metrics in Prometheus and Grafana.

Explore how the OpenTelemetry SDK enables metrics instrumentation, from creating counters and in-memory aggregations to periodic exporting via the collector toward Prometheus scraping.

Configure the node OpenTelemetry SDK and auto-instrumentation to export metrics via a periodic reader to the OpenTelemetry collector, validating the Prometheus-style metrics endpoint.

Instrument a sample app with custom OpenTelemetry metrics by creating metrics.ts, defining monotonic counters and duration histograms for translation requests, enqueued jobs, and validation errors.

Test and instrument the app by building the frontend, running docker-compose, and exploring custom metrics in Prometheus and Grafana, including translation requests totals, language counts, and error types.

Explore how traces flow end-to-end from client requests through a node express server to the collector using the OpenTelemetry SDK, with auto and manual instrumentation.

Learn to auto instrument a front-end for tracing by generating spans for HTTP requests and Redis operations, configure a trace exporter, deploy, and verify traces in Grafana Tempo.

Install and configure the OTLPHTTP exporter to enable auto instrumentation of traces for the translation front-end. Rebuild and run front-end container, generate requests, and view traces in Grafana tempo.

Conduct a hands-on lab to manually instrument traces by creating a tracer and spans such as translation session and validate request, set attributes, and verify in Grafana.

Engage in a hands-on lab on open telemetry by creating a tracer and active spans to instrument a translation endpoint, validate requests, enqueue translation jobs, and observe traces in Grafana.

Walks through debugging an instrumented front-end, tracing errors in a validation flow, and fixing a bug by capturing the active span return value to prevent unsafe continuation.

Refactor instrumentation code by adding a setSpanError helper and a centralized validateTranslationRequest function, improving OpenTelemetry tracing and error handling.

Explore how the OpenTelemetry SDK instruments logs, auto-injects trace and span IDs, and exports them from the collector to Loki via OTLP, with WinStone logging and manual instrumentation.

Instrument logs with auto instrumentation to inject trace and span IDs for log-to-trace correlation in Grafana. Replace console logs with logger calls and export logs via otlp-http for Loki, OpenTelemetry.

Apply auto instrumentation for logs with a Winston logger and OTLP log exporter, migrate console logs to structured attributes, and run the front-end to observe observability in the Grafana dashboard.

Test deployment by looping curl requests to generate translations and then review Grafana logs and Tempo traces, using the trace ID to retrieve trace information.

Apply manual instrumentation to the front-end by logging events such as validation failures, translation sessions, and SSE activity, verify trace and span IDs, and study logs with the AI companion.

Instrument the frontend with manual log statements using an AI assistant, applying snake case and open telemetry semantic conventions to produce meaningful, searchable logs and traces.

Configure Grafana data sources with stable UIDs to enable log-trace correlation between Loki, Tempo, and OpenTelemetry traces, using derived fields to map trace IDs and service names.

Configure and explore log-trace correlations in a hands-on lab, integrating Grafana with Loki, Prometheus, and Tempo, and learn to jump between logs and traces for end-to-end observability.

Refactor the front-end instrumentation to remove hard-coded service names and endpoints, replacing them with environment variables auto-configured by OpenTelemetry, and apply the same for the worker service before deployment.

Refactor configuration for OpenTelemetry observability by replacing hardcoded endpoints with environment variables via docker compose, wiring OTLP traces, metrics, and logs, and standardizing export intervals.

Instrument the distributed system end-to-end with Python worker auto instrumentation, collecting metrics, logs, and traces while enabling distributed context propagation to unify front-end and worker telemetry for Loki.

Apply worker logs auto-instrumentation by configuring OpenTelemetry logs with environment-based resources, a batch log record processor, and otlp exporters, then deploy and visualize logs in Grafana Loki.

Instrument a worker to send traces to the OpenTelemetry collector using auto-instrumentation, configure a traces pipeline for Redis operations to produce spans in Grafana Tempo, deploy and verify.

OpenTelemetry for observability lab demonstrates auto-instrumenting a worker by updating instrumentation.py, configuring trace pipeline components, deploying with docker compose, and validating traces in Grafana.