Catalogue
/
DevOps
/
OpenTelemetry for Application Observability and Distributed Systems

OpenTelemetry for Application Observability and Distributed Systems

A practical three day technical course for participants who are new to OpenTelemetry and want to instrument, collect, process, and export telemetry from modern applications and distributed systems. The agenda progresses from traces, metrics, logs, instrumentation, and context propagation through the OpenTelemetry Collector, OTLP, semantic conventions, sampling, backend integration, and production deployment patterns. The course focuses on building a practical understanding of OpenTelemetry that can be applied across different programming languages, platforms, and observability backends.

What will you learn?

You will learn how OpenTelemetry creates a vendor-neutral observability layer for applications and infrastructure. You will instrument applications, work with traces, metrics, and logs, configure the OpenTelemetry Collector, propagate context across distributed services, and export telemetry through OTLP. You will also learn how to design scalable collection architectures, control telemetry volume, troubleshoot instrumentation problems, and operate OpenTelemetry in production environments.

  • Instrument applications and services using OpenTelemetry APIs, SDKs, and automatic instrumentation
  • Collect and correlate traces, metrics, and logs across distributed systems
  • Configure OpenTelemetry Collector pipelines for processing and exporting telemetry
  • Design scalable and maintainable observability architectures for production environments

Requirements:

  • Technical background in software development, DevOps, SRE, cloud engineering, infrastructure, or a related field
  • Basic familiarity with application architectures and HTTP-based services
  • General command-line and configuration file experience
  • Previous OpenTelemetry experience is not required

Course Outline*:

*We customize the course outline and content to your specific needs and relevant use cases.

Module 1: OpenTelemetry and modern observability

  • Understanding observability and the role of telemetry in distributed systems
  • Positioning OpenTelemetry as a vendor-neutral instrumentation and telemetry framework
  • Understanding traces, metrics, logs, resources, and baggage
  • Reviewing the flow from instrumented application through collection to an observability backend

Module 2: Distributed tracing fundamentals

  • Understanding traces, spans, parent-child relationships, attributes, events, and status
  • Following a request across multiple services and dependencies
  • Creating spans and adding useful application context
  • Recognising common tracing patterns for HTTP services, databases, messaging, and background processing

Module 3: Instrumenting applications

  • Comparing automatic and code-based instrumentation approaches
  • Configuring OpenTelemetry SDKs and instrumentation libraries
  • Adding custom spans, attributes, events, and application-specific telemetry
  • Deciding what should be instrumented automatically and where custom instrumentation adds value

Module 4: Context propagation and distributed requests

  • Understanding trace context and why propagation is required across service boundaries
  • Injecting and extracting context across HTTP and other supported transports
  • Working with W3C Trace Context and baggage concepts
  • Diagnosing broken traces caused by missing or incorrect context propagation

Module 5: Metrics with OpenTelemetry

  • Understanding counters, gauges, histograms, and common metric use cases
  • Creating application and service-level measurements
  • Selecting meaningful attributes without creating unnecessary cardinality
  • Connecting metrics with service and resource information for operational analysis

Module 6: Logs and signal correlation

  • Understanding OpenTelemetry log records and log instrumentation
  • Correlating logs with trace and span identifiers
  • Enriching telemetry with consistent service and resource attributes
  • Combining traces, metrics, and logs when investigating application behaviour

Module 7: Semantic conventions and telemetry design

  • Understanding OpenTelemetry semantic conventions and standard attribute naming
  • Applying consistent resource, service, HTTP, database, and messaging attributes
  • Using service.name and related resource information to identify workloads reliably
  • Designing custom telemetry without conflicting with established conventions

Module 8: OpenTelemetry Collector fundamentals

  • Understanding receivers, processors, exporters, connectors, and extensions
  • Building trace, metric, and log pipelines in Collector configuration
  • Receiving telemetry through OTLP over gRPC and HTTP
  • Processing and exporting telemetry to one or more observability backends

Module 9: Processing and controlling telemetry

  • Using batching, filtering, enrichment, transformation, and resource processing
  • Removing unnecessary or sensitive telemetry before export
  • Understanding head sampling and tail sampling approaches
  • Balancing observability coverage with telemetry volume, storage, and cost

Module 10: Collector deployment architectures

  • Comparing direct export, agent, gateway, and combined Collector patterns
  • Designing telemetry flows for applications, hosts, containers, and distributed services
  • Understanding Collector deployment considerations for Docker and Kubernetes environments
  • Selecting deployment patterns based on scale, reliability, network boundaries, and backend architecture

Module 11: Backend integration and operational troubleshooting

  • Exporting telemetry through OTLP and other supported protocols
  • Connecting OpenTelemetry with vendor and open-source observability backends
  • Diagnosing missing spans, broken traces, dropped data, exporter failures, and configuration problems
  • Using Collector health information, internal telemetry, and debugging output during investigation

Module 12: Production architecture and operational readiness

  • Designing reliable Collector pipelines with appropriate batching, retries, queueing, and failure handling
  • Managing configuration, credentials, endpoints, and environment-specific settings
  • Monitoring the health and resource consumption of the observability pipeline itself
  • Building a practical production readiness checklist covering instrumentation, propagation, sampling, security, scaling, and maintainability

Hands-on learning with expert instructors at your location for organizations.

4,347€*
Graph Icon - Education X Webflow Template
Level:
intermediate
Clock Icon - Education X Webflow Template
Duration:
21
Hours (days:
3
)
Camera Icon - Education X Webflow Template
Training customized to your needs
Star Icon - Education X Webflow Template
Immersive hands-on experience in a dedicated setting
*Price can range depending on number of participants, change of outline, location etc.

Master new skills guided by experienced instructors from anywhere.

3,012€*
Graph Icon - Education X Webflow Template
Level:
intermediate
Clock Icon - Education X Webflow Template
Duration:
21
Hours (days:
3
)
Camera Icon - Education X Webflow Template
Training customized to your needs
Star Icon - Education X Webflow Template
Reduced training costs
*Price can range depending on number of participants, change of outline, location etc.

Upcoming Sessions

9-11 Feb 2027
Paris
18-20 Feb 2027
Frankfurt
15-17 Apr 2027
Madrid
18-20 May 2027
London
25-27 May 2027
Dublin
7-9 Jul 2027
Dublin

Can't find a suitable date? Get in touch and we'll arrange one that works for you.

We use cookies to improve site navigation, analyse how the site is used, and support our marketing. You can accept all cookies, reject non-essential ones, or choose individual categories. Read our Cookie Notice