Elixir og Phoenix: Skalerbar backendutvikling · leksjon

Overvåking med Telemetry og måledata

Integrer Telemetry i applikasjonen din for å sende ut måledata og få innsikt i kjøreatferden.

Leksjon 2 av 411 trinn

Overvåking med Telemetry og måledata er en gratis leksjon i Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Elixir og Phoenix: Skalerbar backendutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hva er Elixir Telemetry?

I Elixir er Telemetry et kraftig bibliotek på lavt nivå for utsending av hendelser. Det hjelper deg med å forstå hva som skjer inne i applikasjonen mens den kjører.

Det er innebygd i Elixir/OTP, noe som gjør det til en standardmetode for å observere systemer.
Tenk på det som et sentralnervesystem for hendelsene i applikasjonen din.
Det gjør det mulig å samle inn måledata, spore operasjoner og overvåke ytelsen.

Det er avgjørende for å bygge applikasjoner som er enkle å observere og vedlikeholde.

Hendelser: Kjernen i Telemetry

Telemetry fungerer ved å sende ut hendelser. En hendelse er et signal om at noe bemerkelsesverdig har skjedd i applikasjonen.

Hver hendelse har et unikt navn (en liste med atomer, for eksempel [:my_app, :user, :login]).
Hendelser kan inneholde målinger (numeriske verdier, for eksempel varighet) og metadata (ytterligere kontekst, for eksempel bruker-ID).
Du sender ikke ut hendelser direkte. I stedet bruker du funksjoner som pakker inn koden din.

Mål varighet med Telemetry.span

En vanlig bruk av Telemetry er å måle hvor lang tid en operasjon tar. Dette gjøres med :telemetry.span/3.

Den kjører en gitt funksjon og måler kjøretiden.
Den sender ut to hendelser: én når spanet starter, og én når det avsluttes.
Slutthendelsen inneholder varigheten som en måling.

Dette er nyttig for profilering av funksjonskall eller databasespørringer.

Send ut separate hendelser med Telemetry.execute

Noen ganger ønsker du bare å signalisere at en handling har funnet sted, uten nødvendigvis å måle varigheten. Da bruker du :telemetry.execute/3.

Den sender ut én enkelt hendelse med angitte målinger og metadata.
Dette er nyttig for å spore ting som treff og bom i hurtigbufferen, fullførte bakgrunnsjobber eller bestemte API-kall.
Det er en enklere og mer direkte måte å sende ut en enkelt hendelse på et bestemt tidspunkt.

Kode: Send ut et Telemetry-span

La oss se :telemetry.span/3 i praksis. Dette eksempelet simulerer en «processing»-oppgave og måler varigheten.

Vi definerer en enkel modul og kaller en funksjon som pakker arbeidet inn i et 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!)")

Koble til Telemetry-håndterere

Å sende ut hendelser er bare halve historien! For å gjøre noe nyttig med dem må du koble til håndterere.

En håndterer er en funksjon som kalles hver gang en bestemt Telemetry-hendelse sendes ut.
Du kobler til en håndterer med :telemetry.attach/4, der du angir hendelsesnavnet og håndtererfunksjonen.
Håndterere lar deg reagere på hendelser: logge dem, sende dem til et målesystem eller utløse andre handlinger.

De fungerer som lyttere for de interne signalene i applikasjonen din.

Strukturen til en håndtererfunksjon

En Telemetry-håndtererfunksjon må ta imot fire argumenter:

event_name: Navnet på hendelsen (for eksempel [:my_app, :user, :login]).
measurements: Et map med numeriske verdier knyttet til hendelsen (for eksempel %{duration: 123456}).
metadata: Et map med ytterligere kontekst (for eksempel %{user_id: 123}).
config: Eventuell egendefinert konfigurasjon som ble sendt med ved tilkoblingen.

Logikken i håndtereren bruker disse argumentene til å behandle hendelsen.

Kode: Koble til og håndtere hendelser

La oss nå legge til en håndterer i det forrige eksempelet. Denne håndtereren logger ganske enkelt detaljene om hendelsen.

Legg merke til hvordan :telemetry.attach/4 kobler håndtererfunksjonen vår til det bestemte hendelsesnavnet.

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 som kilde til måledata

Telemetry er ikke et målesystem i seg selv, men det er en utmerket kilde til måledata. Ved å koble til håndterere kan du sende hendelser videre til dedikerte målebiblioteker.

Biblioteker som telemetry_metrics kan aggregere Telemetry-hendelser til tellere, målere og histogrammer.
Disse aggregerte måledataene eksporteres ofte til overvåkingssystemer som Prometheus eller Datadog.
Dette skillet holder Telemetry lett og fleksibelt, slik at du kan velge den måleplattformen du foretrekker.

Hurtigsjekk: Telemetry-håndterere

Du har lært om å sende ut og håndtere Telemetry-hendelser. La oss teste forståelsen din.

Besvar den i den interaktive leksjonen

Oppsummering: Telemetry for observerbarhet

I denne leksjonen utforsket vi Elixirs Telemetry-bibliotek:

Telemetry er et system for utsending av hendelser som brukes til intern observerbarhet i applikasjoner.
Det bruker hendelser med unike navn, målinger og metadata.
:telemetry.span/3 måler varigheten av kodekjøring.
:telemetry.execute/3 sender ut separate hendelser på et bestemt tidspunkt.
Håndterere er funksjoner som kobles til via :telemetry.attach/4 for å behandle hendelser.
Telemetry-hendelser er en viktig kilde for å bygge applikasjonens måledata.

Å beherske Telemetry er avgjørende for å forstå og overvåke Elixir-applikasjonene dine på en effektiv måte!

Gratis å komme i gang

Lær deg Elixir med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Overvåking med Telemetry og måledata» gratis?

Ja – hele teksten i «Overvåking med Telemetry og måledata» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Elixir og Phoenix: Skalerbar backendutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Overvåking med Telemetry og måledata»?

Integrer Telemetry i applikasjonen din for å sende ut måledata og få innsikt i kjøreatferden. Du øver på Elixir og Phoenix: Skalerbar backendutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Elixir og Phoenix: Skalerbar backendutvikling?

Ingen tidligere erfaring er nødvendig. Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Overvåking med Telemetry og måledata»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Elixir og Phoenix: Skalerbar backendutvikling-leksjonen?

Ja. Alle Elixir og Phoenix: Skalerbar backendutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Elixir og Phoenix: Skalerbar backendutvikling