> ## 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.

# Logging vanuit Elixir

export const VersionRequirements = ({versions = []}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const boundaries = {
    upper: " or lower",
    exact: "",
    lower: " or higher"
  };
  const containerStyle = {
    marginTop: "0.5rem",
    marginBottom: "1.5rem"
  };
  const lineStyle = {
    display: "block",
    margin: "0 0 0.35rem 0",
    fontSize: "0.875rem",
    lineHeight: "1.4"
  };
  const pillBaseStyle = {
    display: "inline-block",
    padding: "0.1em 0.4em",
    borderRadius: "0.25rem",
    border: "1px solid",
    fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
    fontSize: "0.85em",
    fontWeight: 500
  };
  const pillColors = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#e9d5ff",
      color: "#9333ea"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde68a",
      color: "#ca8a04"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#99f6e4",
      color: "#0d9488"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde68a",
      color: "#ca8a04"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#bbf7d0",
      color: "#16a34a"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#bfdbfe",
      color: "#2563eb"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fecaca",
      color: "#dc2626"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fed7aa",
      color: "#ea580c"
    }
  };
  const defaultPillColor = {
    background: "#f4f4f5",
    borderColor: "#e4e4e7",
    color: "#52525b"
  };
  const getPillStyle = name => ({
    ...pillBaseStyle,
    ...pillColors[name] || defaultPillColor
  });
  const getBoundText = bound => {
    return boundaries[bound] || boundaries.lower;
  };
  return <div style={containerStyle}>
      {versions.map((v, i) => <p key={`${v.name}-${v.version}-${v.bound || "lower"}-${i}`} style={lineStyle}>
          This feature requires{" "}
          <code style={getPillStyle(v.name)}>{v.name}</code> version {v.version}
          {getBoundText(v.bound)}.
        </p>)}
    </div>;
};

export const Compatibility = ({versions = [], label = "Available in"}) => {
  if (!Array.isArray(versions) || versions.length === 0) {
    return null;
  }
  const defaultPillStyle = {
    borderColor: "#d4d4d8",
    background: "#f4f4f5",
    color: "#3f3f46"
  };
  const pillStyles = {
    "AppSignal for Elixir": {
      background: "#f3e8ff",
      borderColor: "#d8b4fe",
      color: "#6b21a8"
    },
    "AppSignal for Front-end": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Go": {
      background: "#ccfbf1",
      borderColor: "#5eead4",
      color: "#115e59"
    },
    "AppSignal for JavaScript": {
      background: "#fef9c3",
      borderColor: "#fde047",
      color: "#854d0e"
    },
    "AppSignal for Node.js": {
      background: "#dcfce7",
      borderColor: "#86efac",
      color: "#166534"
    },
    "AppSignal for Python": {
      background: "#dbeafe",
      borderColor: "#93c5fd",
      color: "#1e40af"
    },
    "AppSignal for Ruby": {
      background: "#fee2e2",
      borderColor: "#fca5a5",
      color: "#991b1b"
    },
    "AppSignal for Rust": {
      background: "#ffedd5",
      borderColor: "#fdba74",
      color: "#9a3412"
    }
  };
  const getPillStyle = name => ({
    ...defaultPillStyle,
    ...pillStyles[name] || ({})
  });
  return <div className="not-prose my-4 rounded-lg border border-zinc-200 bg-zinc-50 px-4 py-3 text-sm dark:border-white/10 dark:bg-white/5">
      <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
        <span className="font-semibold text-zinc-700 dark:text-zinc-200">
          {label}:
        </span>
        {versions.map((v, i) => <span key={`${v.name}-${v.version}-${i}`} className="inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium" style={getPillStyle(v.name)}>
            <span>{v.name}</span>
            <span className="opacity-70">
              {v.version}
              {v.exact ? "" : "+"}
            </span>
          </span>)}
      </div>
    </div>;
};

<VersionRequirements
  versions={[
{ name: "AppSignal for Elixir", version: "2.6.0" }
]}
/>

Deze documentatie beschrijft hoe u logging configureert met de AppSignal for Elixir-integratie.

## Logging configureren

<Warning>
  🔐 Stuur geen <strong>Persoonlijk Identificeerbare Informatie (PII)</strong> naar AppSignal. Filter PII (bijv. namen, e-mailadressen) uit logs en gebruik in plaats daarvan een ID, hash of gepseudonimiseerde identificator. <br /> <br /> Voor **onder HIPAA vallende entiteiten** vindt u meer informatie over het ondertekenen van een Business Associate Agreement (BAA) in onze [documentatie over Business Add-Ons](/support/business-add-ons).
</Warning>

U hoeft geen logbron aan te maken om logs te versturen vanuit de AppSignal for Elixir-integratie. Er wordt automatisch een "application"-logbron aangemaakt.

### Logger Handler

<Compatibility
  versions={[
{ name: "AppSignal for Elixir", version: "2.7.10" },
{ name: "Elixir", version: "1.15" },
]}
/>

U kunt de Erlang `:logger` configureren om de `Appsignal.Logger.Handler`-module als handler te gebruiken, door de functie `Appsignal.Logger.Handler.add/2` aan te roepen in uw `Application.start/2`-callback:

<CodeGroup>
  ```elixir Elixir theme={null}
  @impl true
  def start(_type, _args) do
    Appsignal.Logger.Handler.add("phoenix")
  end
  ```
</CodeGroup>

Het meegegeven argument is de groepsnaam die beschrijft vanwaar u logt. Deze groepsnaam kan in AppSignal worden gebruikt om uw logs te filteren.

### Logger Backend

<Tip>
  Vanaf Elixir-versie 1.15 worden Elixir logger-backends niet langer
  aanbevolen. Zie de sectie [Logger Handler](#logger-handler) hierboven voor
  het aanbevolen alternatief.
</Tip>

In plaats van een Elixir logger-handler te gebruiken, kunt u de Elixir logger-backend configureren om de `Appsignal.Logger.Backend`-module als backend te gebruiken door de onderstaande code in het bestand `config/runtime.exs` te plaatsen:

<CodeGroup>
  ```elixir Elixir theme={null}
  config :logger, backends: [:console, {Appsignal.Logger.Backend, [group: "phoenix"]}]
  ```
</CodeGroup>

De optie `group` beschrijft vanwaar u logt. Deze groepsnaam kan in AppSignal worden gebruikt om uw logs te filteren.

U kunt de backend ook toevoegen met de functie `add_backend/2` in uw `Application.start/2`-callback:

<CodeGroup>
  ```elixir Elixir theme={null}
  @impl true
  def start(_type, _args) do
    Logger.add_backend(Appsignal.Logger.Backend, group: "phoenix")
  end
  ```
</CodeGroup>

### Elixir Logger

Om logs naar AppSignal te sturen zonder de Elixir Logger-backend te gebruiken, kunt u een van de logging-functies van `Appsignal.Logger` gebruiken en deze voorzien van een `groupname` die definieert vanwaar u logt. Bijvoorbeeld, als wij zouden loggen vanuit een helper voor het factureren van klanten:

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Logger.info(
    "invoice_helper",
    "Generating invoice for customer 129"
  )
  ```
</CodeGroup>

## Gebruik

### Logs versturen

Net als de Elixir/Phoenix logger-klasse kunt u de severity-niveau van uw logs definiëren met `fatal`, `error`, `warning`, `info` en `debug`:

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Logger.warning(
    "app",
    "Something's gone terribly wrong here"
  )
  ```
</CodeGroup>

U kunt aangepaste attributen als het laatste argument doorgeven om loginformatie te versturen die kan worden gebruikt bij het filteren en opvragen van logs:

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Logger.info(
    "invoice_helper",
    "Generated invoice for customer #{customer.id}",
    %{ customer_id: customer.id, invoice_id: invoice.id }
  )
  ```
</CodeGroup>

U kunt op berichtinhoud en attribuutwaarden filteren en opvragen met behulp van onze [zoeksyntaxis](/logging/query-syntax).

Eenmaal geconfigureerd, worden de gewenste attributen als log-tags naar AppSignal verstuurd en zijn ze opvraagbaar in de AppSignal logging-interface.

## Formaten

### Automatisch gedetecteerd formaat

<Compatibility versions={[{ name: "AppSignal for Elixir", version: "2.15.11" }]} />

Het AppSignal for Elixir-pakket detecteert het formaat van de logregel standaard automatisch als JSON, Logfmt of plaintext en parseert er attributen uit.
U hoeft het logformaat niet handmatig in te stellen, tenzij het niet correct wordt gedetecteerd.
[Laat het ons ook weten](mailto:support@appsignal.com?subject=Log%20format%20auto%20detection%20not%20working) als dit niet automatisch werkt.

<CodeGroup>
  ```elixir Elixir theme={null}
  # Plaintext format
  Appsignal.Logger.info(
    "invoice_helper",
    "Generated invoice"
  )
  # Logfmt format
  Appsignal.Logger.info(
    "invoice_helper",
    "Generated invoice invoice_id=A145 for customer customer_id=123"
  )
  # JSON format
  Appsignal.Logger.info(
    "invoice_helper",
    ~s({"message": "Generated invoice for customer", "invoice_id": "A145", "customer_id": "123"})
  )
  ```
</CodeGroup>

### Logfmt

De AppSignal Logger kan expliciet worden geconfigureerd om te verwachten dat de regel in Logfmt-formaat is en hier attributen uit te parsen.
Gebruik deze optie wanneer u een oudere versie van het AppSignal for Elixir-pakket gebruikt die geen [automatische formaatdetectie](#auto-detected-format) ondersteunt.

Het Logfmt-formaat kan worden opgegeven wanneer de AppSignal-logger wordt aangeroepen door de waarde `:logfmt` als het laatste argument toe te voegen.

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Logger.info(
    "invoice_helper",
    "Generated invoice invoice_id=A145 for customer customer_id=123",
    :logfmt
  )
  ```
</CodeGroup>

### JSON

De AppSignal Logger kan expliciet worden geconfigureerd om te verwachten dat de regel in JSON-formaat is en hier attributen uit te parsen.
Gebruik deze optie wanneer u een oudere versie van het AppSignal for Elixir-pakket gebruikt die geen [automatische formaatdetectie](#auto-detected-format) ondersteunt.

Het JSON-formaat kan worden opgegeven wanneer de AppSignal-logger wordt aangeroepen door de waarde `:json` als het laatste argument toe te voegen.

<CodeGroup>
  ```elixir Elixir theme={null}
  Appsignal.Logger.info(
    "invoice_helper",
    ~s({"message": "Generated invoice for customer", "invoice_id": "A145", "customer_id": "123"}),
    :json
  )
  ```
</CodeGroup>

Alleen primitieve niet-geneste waarden (getallen, strings, booleans en `null`) worden als log-attributen weergegeven. Alle andere attributen worden verwijderd.

## Logs filteren

U kunt [de configuratieoptie `ignore_logs`](/elixir/configuration/options#option-ignore_logs) gebruiken om logregels op basis van hun bericht te negeren. Zie [onze gids Logs negeren](/guides/filter-data/ignore-logs) voor meer informatie.

## Hulp nodig?

Nadat u uw Elixir-applicatie hebt geconfigureerd om logs te versturen, zouden er logs in AppSignal moeten verschijnen. Als u twijfelt over deze stap of AppSignal geen logs ontvangt, kunt u altijd [contact opnemen](mailto:support@appsignal.com) voor hulp. Wij helpen u graag weer op weg!
