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

# Rack

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>;
};

Um Rack-Anwendungen zu instrumentieren, stellt AppSignal eine Rack-Instrumentation-Middleware bereit. Wenn Sie eines der unterstützten Rack-Frameworks wie [Rails], [Sinatra], [Hanami], [Grape] oder [Padrino] verwenden, empfehlen wir, stattdessen diese Instrumentationen zu verwenden.

## Instrumentation-Middleware hinzufügen

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

<Tip>
  Verwenden Sie ein älteres AppSignal-Ruby-Gem? Folgen Sie [unserer Legacy-Anleitung](#using-the-legacy-instrumentation-middleware).
</Tip>

Um [AppSignal][integrate] in eine Rack-Anwendung zu integrieren, müssen wir zunächst AppSignal laden, [konfigurieren][configuration] und starten.

Instrumentieren Sie dann die Rack-App, indem Sie unsere Rack-`EventMiddleware` und `InstrumentationMiddleware` zum Middleware-Stack hinzufügen.

Diese Dokumentation erklärt, wie Sie dies in der `config.ru`-Datei Ihrer Anwendung tun.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config.ru
  require "appsignal"                           # Load AppSignal

  Appsignal.start                               # Start the AppSignal integration

  # Add the Rack EventMiddleware first
  use Appsignal::Rack::EventMiddleware
  # Add the Rack InstrumentationMiddleware
  use Appsignal::Rack::InstrumentationMiddleware

  # Load your app with a require statement here, like
  require_relative "app"

  # Add other middleware here if needed

  # Finally, run the app
  use MyApp.run
  ```
</CodeGroup>

Stellen Sie sicher, dass die `EventMiddleware` und die `InstrumentationMiddleware` so früh wie möglich im Middleware-Stack der Anwendung registriert werden. Je früher diese Middlewares registriert sind, desto mehr Request-Laufzeit instrumentiert die Middleware. Wenn andere Middlewares zuvor registriert werden, instrumentiert unsere Middleware diese anderen Middlewares nicht.

Nachdem Sie die `EventMiddleware` und die `InstrumentationMiddleware` zum Middleware-Stack Ihrer App hinzugefügt haben, muss [die Action](#setting-the-action-name) für jede Route in Ihrer App in AppSignal gesetzt werden. Ohne einen Action-Namen, der Anfragen gruppiert, meldet die Event-Middleware keine Anfrage-Informationen.

Für tiefere Einblicke in den Betrieb Ihrer Rack-Anwendung empfehlen wir, [zusätzliche Instrumentation][instrumentation] zu den Endpunkten der Anwendung hinzuzufügen.

### Die Rack-Event-Middleware

Wir empfehlen, unsere Rack-Event-Middleware zu allen Rack-Anwendungen hinzuzufügen. Diese Middleware stellt sicher, dass wir Folgendes erfassen:
Die AppSignal-Rack-Event-Middleware bietet die folgenden Funktionen:

* Instrumentation des Requests und Aufzeichnung eines `process_request.rack`-Events.
* Meldung von Ausnahmen, die in der App und in Middlewares auftreten.
* Erfassung des Response-Statuscodes als Tag `response_status` im Sample.
* Erfassung des Response-Statuscodes als Metrik `response_status` mit den Tags `namespace` und `status`.

### Die Rack-Instrumentation-Middleware

Wir empfehlen, zusätzlich zur `Appsignal::Rack::EventMiddleware` auch die `AppSignal::Rack::InstrumentationMiddleware` zur App hinzuzufügen. Diese Middleware ergänzt die Instrumentation der Event-Middleware, indem sie Tags für den Request-Pfad und die Request-Methode hinzufügt sowie die Verarbeitung und das Schließen des Response-Bodys verfolgt.

Die Instrumentation-Middleware bietet die folgenden Funktionen:

* Instrumentation des Requests und Aufzeichnung eines `process_request.rack`-Events.
* Meldung von Ausnahmen, die in der App auftreten.
* Erfassung des Request-Pfads und der Request-Methode als Tags im Sample.
* Instrumentation der Verarbeitung des Response-Bodys und Aufzeichnung eines `process_response_body.rack`-Events für diese Operation.
* Instrumentation des Schließens des Response-Bodys und Aufzeichnung eines `close_response_body.rack`-Events für diese Operation.

## Verwendung der Legacy-Instrumentation-Middleware

<Compatibility versions={[{ name: "AppSignal for Ruby", version: "v1.1.6" }]} />

<Warning>
  Die GenericInstrumentation-Middleware wurde in Ruby Gem 3.10.0 als veraltet markiert.
  Bitte verwenden Sie stattdessen die [neue Anleitung](#add-the-instrumentation-middleware).
</Warning>

Um [AppSignal][integrate] in eine Rack-Anwendung zu integrieren, müssen wir zunächst AppSignal laden, [konfigurieren][configuration] und starten.

Instrumentieren Sie dann die Rack-App, indem Sie unsere Rack-`GenericInstrumentation`-Middleware zum Middleware-Stack hinzufügen.

Diese Dokumentation erklärt, wie Sie dies in der `config.ru`-Datei Ihrer Anwendung tun.

<CodeGroup>
  ```ruby Ruby theme={null}
  # config.ru
  # Load and configure AppSignal
  require "appsignal"                           # Load AppSignal

  Appsignal.config = Appsignal::Config.new(
    File.expand_path("../", __FILE__),          # Application root path
    ENV["RACK_ENV"],                            # Application environment
  )
  Appsignal.start                               # Start the AppSignal integration
  Appsignal.start_logger                        # Start logger

  # Load your app with a require statement here, like
  require_relative "app"

  # Add the GenericInstrumentation middleware
  use Appsignal::Rack::GenericInstrumentation

  # Add other middleware here if needed

  # Finally, run the app
  use MyApp.run
  ```
</CodeGroup>

Stellen Sie sicher, dass die `EventMiddleware` und die `InstrumentationMiddleware` so früh wie möglich im Middleware-Stack der Anwendung registriert werden. Je früher diese Middlewares registriert sind, desto mehr Request-Laufzeit instrumentiert die Middleware. Wenn andere Middlewares zuvor registriert werden, instrumentiert unsere Middleware diese anderen Middlewares nicht.

Nachdem Sie die `EventMiddleware` und die `InstrumentationMiddleware` zum Middleware-Stack Ihrer App hinzugefügt haben, muss [die Action](#setting-the-action-name) für jede Route in Ihrer App in AppSignal gesetzt werden. Ohne einen Action-Namen, der Anfragen gruppiert, meldet die Event-Middleware keine Anfrage-Informationen.

Für tiefere Einblicke in den Betrieb Ihrer Rack-Anwendung empfehlen wir, [zusätzliche Instrumentation][instrumentation] zu den Endpunkten der Anwendung hinzuzufügen.

## Action-Name setzen

Setzen Sie einen Action-Namen auf die AppSignal-Transaktion für eine Anfrage, damit wir Endpunkte in unseren Issues und Metriken gruppieren können. Wir empfehlen, pro Endpunkt einen statischen Action-Namen zu verwenden, wie `GET /blog`, `POST /users`, `PUT /users/:id` usw.

Um einen Action-Namen für eine Anfrage zu setzen, rufen Sie den Helper `Appsignal.set_action` aus der App auf.

<Warning>
  Verwenden Sie nicht den Request-Pfad der Route als Action-Namen, wenn der Pfad
  dynamische Segmente enthält. Die Verwendung echter Request-Pfade als Action-Namen
  bricht unsere Gruppierung der Anfragen, indem für jeden möglichen Request-Pfad
  einzigartige Issues erzeugt werden.
</Warning>

<CodeGroup>
  ```ruby Ruby theme={null}
  # app.rb
  require "rack"

  # Example pure-Rack app
  class MyApp
    def call(env)
      case [env["REQUEST_METHOD"], env["PATH_INFO"]]
      when ["GET", "/"]
        Appsignal.set_action("GET /") # Action name set here
        body = <<~BODY
          <h1>Rack example app</h1>

          <ul>
            <li><a href="/slow">Slow request</a></li>
            <li><a href="/error">Error request</a></li>
          </ul>
        BODY
        [200, {"Content-Type" => "text/html"}, [body]]
      when ["GET", "/slow"]
        Appsignal.set_action("GET /slow") # Action name set here
        sleep 1
        [200, {"Content-Type" => "text/plain"}, ["Slow response"]]
      when ["GET", "/error"]
        Appsignal.set_action("GET /error") # Action name set here
        raise "uh oh"
      else
        Appsignal.set_action("NotFound") # Action name set here
        [404, {"Content-Type" => "text/plain"}, ["Page not found"]]
      end
    end
  end
  ```
</CodeGroup>

[configuration]: /ruby/configuration

[integrate]: /ruby/instrumentation/integrating-appsignal.html

[instrumentation]: /ruby/instrumentation/instrumentation.html

[Rails]: /ruby/integrations/rails.html

[Sinatra]: /ruby/integrations/sinatra.html

[Hanami]: /ruby/integrations/hanami.html

[Grape]: /ruby/integrations/grape.html

[Padrino]: /ruby/integrations/padrino.html