Elixir & Phoenix: Scalable Backend Development · Ders

Telemetry ve Metriklerle İzleme

Çalışma zamanı davranışı hakkında içgörü kazanmak ve metrikler üretmek için Telemetry'yi uygulamanıza entegre edin.

Telemetry ve Metriklerle İzleme, CoddyKit'te ücretsiz bir Elixir & Phoenix: Scalable Backend Development dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Elixir & Phoenix: Scalable Backend Development öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Elixir & Phoenix: Scalable Backend Development kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

What is Elixir Telemetry?

In Elixir, Telemetry is a powerful, low-level event dispatching library. It helps you understand what's happening inside your running application.

It's built into Elixir/OTP, making it a standard way to observe systems.
Think of it as a central nervous system for your app's events.
It enables you to collect metrics, trace operations, and monitor performance.

It's crucial for building observable and maintainable applications.

Events: The Core of Telemetry

Telemetry works by emitting events. An event is a signal that something notable has happened in your application.

Each event has a unique name (a list of atoms, e.g., [:my_app, :user, :login]).
Events can carry measurements (numeric values like duration) and metadata (additional context like user ID).
You don't emit events directly; instead, you use functions that wrap your code.

Measuring Duration with Telemetry.span

One common use of Telemetry is to measure how long an operation takes. This is done using :telemetry.span/3.

It executes a given function and measures its execution time.
It emits two events: one when the span starts and one when it ends.
The end event includes the duration as a measurement.

This is great for profiling function calls or database queries.

Emitting Discrete Events with Telemetry.execute

Sometimes, you just want to signal that an action occurred, without necessarily measuring its duration. For this, use :telemetry.execute/3.

It emits a single event with specified measurements and metadata.
Useful for tracking things like cache hits/misses, background job completions, or specific API calls.
It's a simpler, more direct way to emit a single point-in-time event.

Code: Emitting a Telemetry Span

Let's see :telemetry.span/3 in action. This example simulates a 'processing' task and measures its duration.

We define a simple module and call a function that wraps its work in a span.

defmodule MyApp.Worker do
  require Logger

  def process_data(data) do
    Logger.info("Starting data processing...")
    :telemetry.span(
      [:my_app, :worker, :process_data],
      %{input_length: byte_size(data)},
      fn ->
        # Simulate some work
        :timer.sleep(100)
        result = String.upcase(data)
        {:ok, result}
      end
    )
  end
end

# --- Main execution for CoddyKit ---
Logger.info("Calling MyApp.Worker.process_data...")
{:ok, result} = MyApp.Worker.process_data("hello elixir")
IO.puts("Processed result: #{result}")
IO.puts("\n(No Telemetry output yet - we need a handler!)")

Attaching Telemetry Handlers

Emitting events is only half the story! To do something useful with them, you need to attach handlers.

A handler is a function that gets called whenever a specific Telemetry event is emitted.
You attach a handler using :telemetry.attach/4, specifying the event name and your handler function.
Handlers allow you to react to events: log them, send them to a metrics system, or trigger other actions.

They are the listeners of your application's internal signals.

Handler Function Structure

A Telemetry handler function must accept four arguments:

event_name: The name of the event (e.g., [:my_app, :user, :login]).
measurements: A map of numeric values associated with the event (e.g., %{duration: 123456}).
metadata: A map of additional context (e.g., %{user_id: 123}).
config: Any custom configuration passed during attachment.

Your handler logic will use these arguments to process the event.

Code: Attaching and Handling Events

Now let's add a handler to our previous example. This handler will simply log the event details.

Notice how :telemetry.attach/4 links our handler function to the specific event name.

defmodule MyApp.WorkerWithHandler do
  require Logger

  # Define our simple handler function
  def handle_event(event_name, measurements, metadata, _config) do
    Logger.info("\n--- Telemetry Event Received ---")
    Logger.info("Event: #{inspect(event_name)}")
    Logger.info("Measurements: #{inspect(measurements)}")
    Logger.info("Metadata: #{inspect(metadata)}")
    Logger.info("------------------------------")
  end

  # Function that emits a Telemetry event
  def process_data(data) do
    Logger.info("Starting data processing...")
    :telemetry.span(
      [:my_app, :worker, :process_data],
      %{input_length: byte_size(data)},
      fn ->
        :timer.sleep(100)
        result = String.upcase(data)
        {:ok, result}
      end
    )
  end
end

# --- Main execution for CoddyKit ---
# Attach the handler *before* emitting events
:telemetry.attach(
  "my-worker-handler",
  [:my_app, :worker, :process_data], # Event name to listen for
  &MyApp.WorkerWithHandler.handle_event/4, # Our handler function
  nil # Optional config
)
Logger.info("Telemetry handler 'my-worker-handler' attached.")

# Perform some work, which will now trigger the handler
{:ok, result} = MyApp.WorkerWithHandler.process_data("hello world")
IO.puts("Processed result: #{result}")

# Clean up: detach the handler (good practice in tests/scripts)
:telemetry.detach("my-worker-handler")
Logger.info("Telemetry handler 'my-worker-handler' detached.")

Telemetry as a Metrics Source

Telemetry is not a metrics system itself, but it's an excellent source for them. By attaching handlers, you can feed events into dedicated metrics libraries.

Libraries like telemetry_metrics can aggregate Telemetry events into counters, gauges, and histograms.
These aggregated metrics are then often exported to monitoring systems like Prometheus or Datadog.
This separation keeps Telemetry lightweight and flexible, allowing you to choose your preferred metrics backend.

Quick Check: Telemetry Handlers

You've learned about emitting and handling Telemetry events. Let's test your understanding.

Recap: Telemetry for Observability

In this lesson, we explored Elixir's Telemetry library:

Telemetry is an event dispatching system for internal application observability.
It uses events with unique names, measurements, and metadata.
:telemetry.span/3 measures code execution duration.
:telemetry.execute/3 emits discrete, point-in-time events.
Handlers are functions attached via :telemetry.attach/4 to process events.
Telemetry events are a prime source for building application metrics.

Mastering Telemetry is key to understanding and monitoring your Elixir applications effectively!

Sıkça Sorulan Sorular

“Telemetry ve Metriklerle İzleme” dersi ücretsiz mi?

Evet — “Telemetry ve Metriklerle İzleme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Elixir & Phoenix: Scalable Backend Development kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Elixir & Phoenix: Scalable Backend Development kursu toplamda 4 dersten oluşur.

“Telemetry ve Metriklerle İzleme” dersinde ne öğreneceğim?

Çalışma zamanı davranışı hakkında içgörü kazanmak ve metrikler üretmek için Telemetry'yi uygulamanıza entegre edin. Elixir & Phoenix: Scalable Backend Development ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Elixir & Phoenix: Scalable Backend Development öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Elixir & Phoenix: Scalable Backend Development, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Telemetry ve Metriklerle İzleme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Elixir & Phoenix: Scalable Backend Development dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Elixir & Phoenix: Scalable Backend Development dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Elixir'de Karşılaştırmalı Ölçüm ve Profil Oluşturma
Telemetry ve Metriklerle İzleme
Hata İşleme ve Yapılandırılmış Günlük Kaydı
OpenTelemetry ile Dağıtık İzleme

← Elixir & Phoenix: Scalable Backend Development Sayfasına Dön