> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Event formatters

Event formatters zijn helper-klassen om event-metadata voor AppSignal-transacties te formatteren. In de AppSignal gem worden event formatters gebruikt om event-metadata van [ActiveSupport::Notifications-instrumentation][as_instrumentation] events naar AppSignal-event-metadata te formatteren.

Wanneer een codeblock wordt geïnstrumenteerd door ActiveSupport::Notifications, registreert AppSignal het event op de transacties, net zoals het zou doen voor de [`Appsignal.instrument` helper][instrument_helper]. Event formatters maken het mogelijk om de data die aan de `ActiveSupport::Notifications.instrument`-methodeaanroep wordt doorgegeven, te formatteren voor AppSignal-events.

De metadata voor de events die door de event formatters worden geformatteerd, is zichtbaar op detailpagina's van performance-incidenten in de event timeline. Beweeg met de muis over een specifiek event en de pop-up bij mouseover toont details zoals de exacte database die wordt opgevraagd of de query die werd uitgevoerd.

<Tip>
  **Let op**: Als er geen andere redenen zijn om
  [`ActiveSupport::Notifications`][as_instrumentation] instrumentation te gebruiken dan
  AppSignal-instrumentation, raden we aan de [`Appsignal.instrument`
  helper][instrument_helper] te gebruiken voor instrumentation. Het gebruik van
  `ActiveSupport::Notifications` voegt meer overhead toe dan rechtstreeks
  `AppSignal.instrument` aanroepen. Er is dan ook geen event formatter nodig, omdat
  `AppSignal.instrument` de metadata direct accepteert om in te stellen.
</Tip>

## Een event formatter maken

Een AppSignal event formatter is een klasse met één instance-methode, `format`. Deze format-methode ontvangt de event payload Hash en moet een Array met drie waarden retourneren.

Het is mogelijk om een event formatter toe te voegen voor libraries die ActiveSupport::Notifications-instrumentation gebruiken, maar let erop dat er niet al een event formatter voor geregistreerd is.

Het is ook mogelijk om een event formatter te maken voor uw eigen events. Houd bij het toevoegen van uw eigen event-namen rekening met de richtlijnen voor [event-naming](/api/event-names).

Elke event formatter ontvangt een "payload" Hash met event-metadata waaruit de event formatter de metadata kan formatteren voor het event in AppSignal. Deze AppSignal-event-metadata moet in deze volgorde in een Array worden geretourneerd door de event formatter:

<CodeGroup>
  ```ruby Ruby theme={null}
  def format(payload)
    [
      "event title",
      "event body",
      Appsignal::EventFormatter::DEFAULT
    ]
  end
  ```
</CodeGroup>

1. Een event title (`String`)
   * Een meer beschrijvende titel van een event, zoals `"Fetch current user"` of `"Fetch blog post comments"`. Deze verschijnt naast de naam van het event in de event tree op de performance-sample-pagina om iets meer context te geven over wat er gebeurt.
2. Een event body (`String`)
   * Meer details, zoals de databasequery die door het event werd gebruikt.
3. Een event body-format (`Integer`)
   * Body format ondersteunt formatters om de gegeven data in het `body`-argument te scrubben om eventuele gevoelige data uit de waarde te verwijderen. Momenteel zijn er twee ondersteunde waarden voor het `body_format`-argument.
     * `Appsignal::EventFormatter::DEFAULT`
       * Deze standaardwaarde geeft aan AppSignal aan om de waarde intact te laten en geen data te scrubben.
     * `Appsignal::EventFormatter::SQL_BODY_FORMAT`
       * De waarde `SQL_BODY_FORMAT` geeft aan AppSignal aan om uw data door de SQL-sanitizer te halen en eventuele waarden in SQL-queries te scrubben.

<CodeGroup>
  ```sql SQL theme={null}
  -- An event body with the value of:
  SELECT * FROM users WHERE email = 'hector@appsignal.com' AND password = 'iamabot'
  -- becomes
  SELECT * FROM users WHERE email = ? AND password = ?
  ```
</CodeGroup>

<Warning>
  **Waarschuwing**: de event formatter heeft geen exception handling omheen.
  Als de custom event formatter een error werpt, crasht dit de webrequest
  of background job.
</Warning>

## Voorbeeld van een event formatter

<CodeGroup>
  ```ruby Ruby theme={null}
  # A custom event formatter class
  class MyCustomEventFormatter
    def format(payload)
      [
        payload[:title],
        payload[:body],
        Appsignal::EventFormatter::DEFAULT
      ]
    end
  end

  # Register the custom event formatter class for a specific event
  Appsignal::EventFormatter.register("event.custom", MyCustomEventFormatter)
  # Can be registerd multiple times for other event names
  Appsignal::EventFormatter.register("other_event.custom", MyCustomEventFormatter)
  ```
</CodeGroup>

Wanneer u vervolgens een codeblock instrumenteert, gebruikt u de event-naam die geregistreerd is voor uw custom event formatter.

<CodeGroup>
  ```ruby Ruby theme={null}
  ActiveSupport::Notifications.instrument(
    "event.custom", # Use the registered event name
    { # Pass along event metadata
      :title => "some event name",
      :body => "some event body"
    }
  ) do
    sleep 2
  end
  ```
</CodeGroup>

## Wijzigingen in gem 2.5

In AppSignal voor Ruby gem versie `2.5.2` zijn enkele wijzigingen aangebracht in hoe event formatters worden geregistreerd. De oude methode voor het registreren van event formatters is in deze release verouderd verklaard en wordt verwijderd in versie `3.0` van de Ruby gem.

De nieuwe methode voor het registreren van EventFormatters maakt het mogelijk om custom formatters te registreren nadat AppSignal is geladen. Hierdoor kunnen EventFormatters in [Rails-initializers](http://guides.rubyonrails.org/configuring.html#using-initializer-files) worden geregistreerd.

In gem versie `2.5.1` en ouder is het mogelijk om een event formatter te registreren zoals het volgende voorbeeld, door de `register`-methode in de klasse zelf aan te roepen.

<CodeGroup>
  ```ruby Ruby theme={null}
  # Pre 2.5.2 method of registering event formatters
  # This method is now deprecated
  class MyCustomEventFormatter < Appsignal::EventFormatter
    register "event.custom"

    def format(payload)
      [payload[:title], payload[:body], Appsignal::EventFormatter::DEFAULT]
    end
  end
  ```
</CodeGroup>

Met de nieuwe opzet is de register-aanroep uit de klasse zelf gehaald, zodat deze direct op de EventFormatter-klasse kan worden geregistreerd.

<CodeGroup>
  ```ruby Ruby theme={null}
  class MyCustomEventFormatter
    def format(payload)
      [payload[:title], payload[:body], Appsignal::EventFormatter::DEFAULT]
    end
  end

  Appsignal::EventFormatter.register("event.custom", MyCustomEventFormatter)
  ```
</CodeGroup>

Dit betekent ook dat uw EventFormatters niet langer een subklasse hoeven te zijn van de klasse `Appsignal::EventFormatter`.

[as_instrumentation]: /ruby/instrumentation/instrumentation.html#activesupport-notifications

[instrument_helper]: /ruby/instrumentation/instrumentation.html#appsignal-instrumentation-helpers