Anwendungen mit OTel-SDKs instrumentieren
Verschaffen Sie sich einen Überblick über OpenTelemetry-SDKs für verschiedene Programmiersprachen. Verstehen Sie, wie sie zum Erzeugen von Logs, Metriken und Traces eingesetzt werden.
Anwendungen mit OTel-SDKs instrumentieren ist eine kostenlose System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What are OTel SDKs?
OpenTelemetry SDKs are language-specific libraries that enable your applications to generate and export observability data. Think of them as the toolkit for making your code observable.
They provide the necessary APIs (Application Programming Interfaces) to capture logs, metrics, and traces directly from your application's runtime.
Role of OpenTelemetry SDKs
SDKs are crucial because they bridge the gap between your application code and the OpenTelemetry standard. They handle the complex work of:
- Collecting Data: Gathering raw observability signals like method calls or variable values.
- Processing Data: Enriching, filtering, and batching this data.
- Exporting Data: Sending the processed data to an observability backend (like Jaeger, Prometheus, or an ELK stack).
Key OTel SDK Components
An OpenTelemetry SDK typically includes several core components that work together:
- Providers: Such as
TracerProvider,MeterProvider, andLoggerProvider, which manage the creation of Tracers, Meters, and Loggers. - Processors/Readers: These define how collected data (spans, metrics, log records) is processed before being sent to an exporter.
- Exporters: Components that send the processed data to an external system, like a console or a remote endpoint.
Tracing with OTel SDKs
When you want to trace requests through your system, OpenTelemetry SDKs provide tools to create and manage spans. A span represents a single operation within a trace.
The SDK gives you a Tracer object, which you use to start new spans, set attributes on them, and link them to parent spans, effectively building a complete trace of a request's journey.
OTel Tracing Code Example
Here's a simple Python example showing how to initialize OpenTelemetry and create a basic trace with nested spans. We use a ConsoleSpanExporter to print spans to the console.
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
# 1. Configure the TracerProvider
provider = TracerProvider()
processor = SimpleSpanProcessor(ConsoleSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)
# 2. Get a Tracer
tracer = trace.get_tracer(__name__)
# 3. Create a Span
with tracer.start_as_current_span("my-first-span"):
print("Inside the span!")
with tracer.start_as_current_span("child-span"):
print("Inside the child span!")
print("Tracing example finished.")Metrics with OTel SDKs
OpenTelemetry SDKs allow you to define and record various types of metrics. Metrics are numerical measurements captured over time, useful for aggregated views of system health and performance.
You obtain a Meter object from the SDK, which you then use to create different types of instruments, such as Counters (for incrementing values) or Gauges (for current values).
OTel Metrics Code Example
This Python example demonstrates how to set up OpenTelemetry for metrics and use a Meter to create and update a Counter. The ConsoleMetricExporter prints the collected metrics.
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import ConsoleMetricExporter, PeriodicExportingMetricReader
# 1. Configure the MeterProvider
reader = PeriodicExportingMetricReader(ConsoleMetricExporter())
provider = MeterProvider(metric_readers=[reader])
metrics.set_meter_provider(provider)
# 2. Get a Meter
meter = metrics.get_meter(__name__)
# 3. Create a Counter instrument
counter = meter.create_counter(
"my_example_counter",
description="Counts how many times something happens"
)
# 4. Record a measurement
counter.add(1, {"key": "value"})
counter.add(2, {"another_key": "another_value"})
print("Metrics example finished. May take a moment to export.")Logging with OTel SDKs
OpenTelemetry SDKs also provide a way to capture and enrich logs. While traditional logging often focuses on plain text, OTel logs can be structured and correlated with traces and metrics.
The SDK offers a Logger (or integrates with existing logging frameworks) to create Log Records. These records can then be processed and exported alongside your traces and metrics, providing a unified view.
OTel Logging Code Example
This Python example shows how to integrate OpenTelemetry with the standard Python logging library. Logs emitted through the standard logger are then processed and exported by OTel.
import logging
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import ConsoleLogExporter, SimpleLogRecordProcessor
# 1. Configure the LoggerProvider
provider = LoggerProvider()
processor = SimpleLogRecordProcessor(ConsoleLogExporter())
provider.add_log_record_processor(processor)
set_logger_provider(provider)
# 2. Get a Python standard logger
# and attach the OTel handler
handler = LoggingHandler(logger_provider=provider)
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.INFO)
# 3. Emit a log record
logging.info("This is an info log from OTel SDK!")
logging.warning("A warning occurred.")
print("Logging example finished.")OTel SDKs Quick Check
OpenTelemetry SDKs are essential for instrumenting applications. Which of the following is NOT a core component or function provided by an OpenTelemetry SDK?
Recap: OTel SDKs
You've learned that OpenTelemetry SDKs are the foundational tools for instrumenting your applications across different programming languages.
- They provide the APIs to generate traces, metrics, and logs.
- They handle the processing and exporting of this data to your chosen observability backend.
- By using SDKs, you ensure your application's observability data adheres to the OpenTelemetry standard, making it portable and vendor-agnostic.
Next, you'll dive deeper into how to effectively instrument your applications.
Lerne System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 12
- Lektionen
- 48
Häufig gestellte Fragen
Ist die Lektion „Anwendungen mit OTel-SDKs instrumentieren“ kostenlos?
Ja — der vollständige Text von „Anwendungen mit OTel-SDKs instrumentieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Anwendungen mit OTel-SDKs instrumentieren“?
Verschaffen Sie sich einen Überblick über OpenTelemetry-SDKs für verschiedene Programmiersprachen. Verstehen Sie, wie sie zum Erzeugen von Logs, Metriken und Traces eingesetzt werden. Du übst System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) zu starten?
Keine Vorkenntnisse erforderlich. System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Anwendungen mit OTel-SDKs instrumentieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Lektion Code schreiben und ausführen?
Ja. Jede System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Der OpenTelemetry-Standard
- OTel-Collector und Exporter
- Anwendungen mit OTel-SDKs instrumentieren
- Signale und semantische Konventionen