Virheenkäsittely ja rakenteinen lokitus
Toteuttakaa vankkoja virheenkäsittelystrategioita ja oppikaa käyttämään rakenteista lokitusta tehokkaaseen virheenkorjaukseen ja valvontaan.
Virheenkäsittely ja rakenteinen lokitus on ilmainen Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.
Miksi virheenkäsittely on tärkeää
Missä tahansa sovelluksessa voi tapahtua virheitä. Käyttäjä voi syöttää virheellisiä tietoja, ulkoinen palvelu voi lakata toimimasta tai tiedostoa ei ehkä ole olemassa.
Virheenkäsittelyssä varaudutaan näihin tilanteisiin ja suunnitellaan sovellus reagoimaan niihin hallitusti. Näin estetään kaatumiset ja varmistetaan sujuva käyttökokemus.
Elixirin ”anna kaatua” -filosofia
Erlang-virtuaalikoneeseen perustuva Elixir noudattaa ainutlaatuista lähestymistapaa, jota kutsutaan ”anna kaatua” -filosofiaksi. Sen sijaan, että kaikilta mahdollisilta virheiltä yritettäisiin suojautua, Elixir-prosessit suunnitellaan eristetyiksi.
Jos prosessi kaatuu, valvoja voi havaita sen ja käynnistää prosessin uudelleen, mikä varmistaa korkean käytettävyyden. Tämä koskee kuitenkin ensisijaisesti prosessitason virheitä. Odotettavissa oleviin toiminnallisiin lopputuloksiin käytetään toista mallia.
Tuplet: {:ok, value} tai {:error, reason}
Toiminnoissa, jotka voivat ennakoitavasti onnistua tai epäonnistua, Elixirissä käytetään usein tuplea: onnistumisesta palautetaan {:ok, result} ja epäonnistumisesta {:error, reason}.
Näin lopputulos ilmaistaan selkeästi eikä odotettavissa olevissa tilanteissa tarvitse käyttää poikkeuksia, mikä tekee koodista selkeämpää.
defmodule AccountService do
def withdraw(balance, amount) when amount > 0 and balance >= amount do
{:ok, balance - amount}
end
def withdraw(balance, amount) when amount <= 0 do
{:error, :invalid_amount}
end
def withdraw(balance, amount) when balance < amount do
{:error, :insufficient_funds}
end
end
IO.puts "Withdrawal 1: #{inspect AccountService.withdraw(100, 50)}"
IO.puts "Withdrawal 2: #{inspect AccountService.withdraw(100, 150)}"
IO.puts "Withdrawal 3: #{inspect AccountService.withdraw(100, 0)}"Tulosten käsittely `case`-rakenteella
Kun funktio palauttaa {:ok, ...}- tai {:error, ...}-tuplen, voit käyttää Elixirin tehokasta hahmonsovitusta case-lauseessa käsitelläksesi molemmat lopputulokset eksplisiittisesti.
Näin virheenkäsittelyn eri haarat ovat hyvin selkeitä ja helposti luettavia.
defmodule PaymentProcessor do
def process_payment(amount, account_balance) do
case AccountService.withdraw(account_balance, amount) do
{:ok, new_balance} ->
IO.puts "Payment successful! New balance: #{new_balance}"
{:ok, new_balance}
{:error, :insufficient_funds} ->
IO.puts "Payment failed: Insufficient funds."
{:error, :payment_failed}
{:error, reason} ->
IO.puts "Payment failed: Unknown reason #{reason}."
{:error, :payment_failed}
end
end
end
# Assuming AccountService from previous scene is available
# Example usage:
PaymentProcessor.process_payment(30, 100)
PaymentProcessor.process_payment(120, 100)`with`-rakenteen voima ketjutuksessa
Kun sinulla on useita operaatioita, jotka voivat palauttaa {:error, ...}-tupleja ja jotka riippuvat aiempien vaiheiden onnistumisesta, with-erikoismuoto on erittäin hyödyllinen.
Sen avulla voit ketjuttaa nämä operaatiot. Jos jokin vaihe palauttaa {:error, ...}-tuplen, with-lohko lopettaa välittömästi ja palauttaa virheen, mikä yksinkertaistaa monimutkaisia suorituspolkuja.
defmodule OrderProcessor do
def process_order(user_id, item_id, quantity) do
with {:ok, user} <- get_user(user_id),
{:ok, item} <- get_item(item_id),
{:ok, total_cost} <- calculate_cost(item, quantity),
{:ok, _} <- deduct_funds(user, total_cost) do
{:ok, "Order processed successfully for user #{user.name}"}
else
{:error, reason} -> {:error, reason}
end
end
defp get_user(1), do: {:ok, %{name: "Alice"}}
defp get_user(_), do: {:error, :user_not_found}
defp get_item(101), do: {:ok, %{price: 20}}
defp get_item(_), do: {:error, :item_not_found}
defp calculate_cost(%{price: p}, q), do: {:ok, p * q}
defp deduct_funds(%{name: "Alice"}, 40), do: {:ok, :deducted}
defp deduct_funds(_, _), do: {:error, :payment_failed}
end
IO.puts "Processing good order: #{inspect OrderProcessor.process_order(1, 101, 2)}"
IO.puts "Processing bad order (item): #{inspect OrderProcessor.process_order(1, 999, 1)}"Peruslokitusta pidemmälle: rakenteinen lokitus
Perinteiset lokit ovat usein pelkkiä tekstiviestejä, joita koneiden on vaikea jäsentää ja joista on vaikea hakea tietoja. Rakenteinen lokitus ratkaisee tämän tuottamalla lokit yhdenmukaisessa, koneellisesti luettavassa muodossa, yleensä JSON-muodossa.
Näin lokitietojen suodattaminen, analysointi ja visualisointi Kibanan tai Splunkin kaltaisilla työkaluilla on paljon helpompaa, ja saat syvällisempää tietoa sovelluksesi toiminnasta.
Luottovalintasi: `Logger`-moduuli
Elixir sisältää tehokkaan sisäänrakennetun lokitusratkaisun: Logger-moduulin. Sen avulla voit lähettää lokiviestejä eri vakavuustasoilla, kuten :debug, :info, :warn ja :error.
Oletusarvoisesti Logger tulostaa viestit konsoliin, mutta sen asetuksia voi muokata laajasti niin, että lokit lähetetään tiedostoihin, ulkoisiin palveluihin tai muihin kohteisiin.
defmodule MyApp do
require Logger
def start_process(id) do
Logger.info "Starting process with ID: #{id}"
# ... some work ...
if id == 101 do
Logger.warn "Process #{id} encountered a minor issue."
else
Logger.debug "Process #{id} completed successfully."
end
end
def critical_error(message) do
Logger.error "Critical error detected: #{message}"
end
end
MyApp.start_process(100)
MyApp.start_process(101)
MyApp.critical_error("Database connection lost")Metatietoja sisältävät kontekstuaaliset lokit
Yksi Logger-moduulin parhaista ominaisuuksista rakenteisessa lokituksessa on mahdollisuus lisätä lokiviesteihin helposti metatietoja (ylimääräisiä avain–arvo-pareja).
Metatiedot tarjoavat tärkeää kontekstia, kuten user_id- tai request_id-tunnuksen tai tiettyjä parametreja. Näin ongelmien jäljittäminen ja tapahtumien kulun ymmärtäminen on paljon helpompaa.
defmodule WebRequestLogger do
require Logger
def log_request(method, path, user_id, duration_ms) do
Logger.info "Request processed",
method: method,
path: path,
user_id: user_id,
duration: "#{duration_ms}ms"
end
def log_error(error_message, user_id, request_id) do
Logger.error error_message,
user_id: user_id,
request_id: request_id,
component: :api_handler
end
end
WebRequestLogger.log_request("GET", "/users/1", 123, 55)
WebRequestLogger.log_error("Invalid API key", 456, "abc-123")Lokitulosteen hallinta tasojen avulla
Jokaisella lokiviestillä on taso (debug, info, warn, error, critical). Elixir-sovelluksen Logger-moduulin voi määrittää tulostamaan vain tietyn tason viestejä tai sitä korkeamman tason viestejä.
Tuotantoympäristössä tasoksi voidaan esimerkiksi määrittää :info, jotta runsaita :debug-lokeja vältetään, kun taas kehitysympäristössä tasoksi voidaan määrittää :debug, jolloin näkyvyys on täydellinen.
- :debug: Yksityiskohtaista tietoa, josta on hyötyä virheenkorjauksessa.
- :info: Yleisiä toimintaan liittyviä viestejä.
- :warn: Mahdollisesti haitallisia tilanteita.
- :error: Virhetapahtumia, jotka saattavat silti sallia sovelluksen jatkaa toimintaansa.
- :critical: Vakavia virhetapahtumia, jotka todennäköisesti aiheuttavat sovelluksen keskeytymisen.
Testaa ymmärryksesi
Mitkä seuraavista ovat strukturoidun lokituksen hyötyjä Elixir-sovelluksissa?
Oppitunnin yhteenveto: Vankkuus ja ymmärrys
Tässä oppitunnissa opitte rakentamaan vankempia Elixir-sovelluksia ja ymmärtämään paremmin niiden toimintaa:
- Opitte tuntemaan Elixirin lähestymistavan virheenkäsittelyyn sekä "Let It Crash" -filosofian.
- Opitte käyttämään
{:ok, value}- ja{:error, reason}-tupleja eksplisiittiseen funktionaaliseen virheenkäsittelyyn. - Opitte hyödyntämään
with-erityismuotoa mahdollisesti epäonnistuvien toimintojen tyylikkääseen ketjuttamiseen. - Tutustuitte strukturoidun lokituksen etuihin koneellisesti luettavien ja haettavien lokien tuottamisessa.
- Opitte käyttämään Elixirin
Logger-moduulia, lisäämään lokeihin hyödyllisiä metatietoja ja määrittämään lokitasoja.
Nämä tekniikat ovat keskeisiä tuotantokäyttöön valmiiden ja havainnoitavien Elixir-järjestelmien kehittämisessä!
Opi Elixir tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 12
- Oppitunnit
- 48
Usein kysytyt kysymykset
Onko oppitunti ”Virheenkäsittely ja rakenteinen lokitus” ilmainen?
Kyllä – oppitunnin ”Virheenkäsittely ja rakenteinen lokitus” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Elixir ja Phoenix: skaalautuva backend-kehitys-kurssin, päivitä CoddyKit PROhon. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Virheenkäsittely ja rakenteinen lokitus”?
Toteuttakaa vankkoja virheenkäsittelystrategioita ja oppikaa käyttämään rakenteista lokitusta tehokkaaseen virheenkorjaukseen ja valvontaan. Harjoittelet Elixir ja Phoenix: skaalautuva backend-kehitys-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Elixir ja Phoenix: skaalautuva backend-kehitys-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.
Kuinka kauan ”Virheenkäsittely ja rakenteinen lokitus”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunnilla?
Kyllä. Jokainen Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Elixirin suorituskyvyn mittaus ja profilointi
- Valvonta Telemetryllä ja metriikoilla
- Virheenkäsittely ja rakenteinen lokitus
- Hajautettu jäljitys OpenTelemetrylla