;
};
Diese Dokumentation beschreibt, wie Sie Logging mit Ihrer AppSignal for Ruby-Integration konfigurieren.
## Logging konfigurieren
🔐 Senden Sie keine personenbezogenen Daten (Personal Identifiable Information, PII) an AppSignal. Filtern Sie PII (z. B. Namen, E-Mail-Adressen) aus Logs und verwenden Sie stattdessen eine ID, einen Hash oder einen pseudonymisierten Bezeichner.
Für **HIPAA-pflichtige Stellen** finden Sie weitere Informationen zum Abschluss eines Business Associate Agreement (BAA) in unserer [Business Add-Ons-Dokumentation](/support/business-add-ons).
Sie müssen keine Log-Quelle erstellen, um Logs aus der AppSignal for Ruby-Integration zu senden. Eine "application"-Log-Quelle wird automatisch erstellt.
### Rails Logger
Sie können das Rails-Framework so konfigurieren, dass es Logs an AppSignal sendet, indem Sie eine Initializer-Datei wie `config/initializers/logging.rb` verwenden:
```ruby Ruby theme={null}
# config/initializers/logging.rb
appsignal_logger = Appsignal::Logger.new("rails")
Rails.logger = ActiveSupport::TaggedLogging.new(appsignal_logger)
```
#### Mehrere Logging-Backends verwenden
Um Logs sowohl an den AppSignal-Logger als auch an den Standard-Logger von Rails zu senden, verwenden Sie den `.broadcast_to`-Helper unseres Loggers:
```ruby Ruby theme={null}
# config/initializers/logging.rb
appsignal_logger = Appsignal::Logger.new("rails")
appsignal_logger.broadcast_to(Rails.logger)
Rails.logger = ActiveSupport::TaggedLogging.new(appsignal_logger)
```
Wir empfehlen, die integrierte Broadcast-Logger-Funktion von Rails nicht zu verwenden, da es Kompatibilitätsprobleme gibt, wenn sie zusammen mit Tagged Logging eingesetzt wird.
#### Unterstützung für Tagged Logging
Die Verwendung von `ActiveSupport::TaggedLogging` in den obigen Beispielen ermöglicht die Unterstützung der Log-Tags von Rails. Wenn Sie beispielsweise das Request-ID-Tag zu den Log-Nachrichten hinzufügen möchten, fügen Sie es dem `config.log_tags`-Array in der Datei `config/application.rb` hinzu:
```ruby Ruby theme={null}
module TestApp
class Application < Rails::Application
config.log_tags = [:request_id]
end
end
```
#### Lograge verwenden
Diese Lograge-Konfiguration ist kein Ersatz für die Rails-Logger-Konfiguration.
Wenn Sie Logs aus `Rails.logger` melden möchten, müssen auch die Schritte zur
[Rails-Logger-Konfiguration](#rails-logger) befolgt werden.
Die [Lograge](https://github.com/roidrage/lograge)-Bibliothek ist eine beliebte Lösung zum Ingestieren strukturierter Rails-*Request*-Logs.
Nachdem Sie das `lograge`-Gem hinzugefügt haben, können Sie es in `config/initializers/lograge.rb` so konfigurieren, dass es Logs an AppSignal sendet:
```ruby Ruby theme={null}
Rails.application.configure do
config.lograge.enabled = true
config.lograge.keep_original_rails_log = true
config.lograge.logger = Appsignal::Logger.new(
"rails",
format: Appsignal::Logger::LOGFMT
)
end
```
Lograge unterstützt keine Log-Level. Alle über Lograge ausgegebenen Logs
erscheinen mit der Severity-Stufe `INFO` in der AppSignal Logging-Oberfläche.
### Sinatra Logger
Sie können Sinatra so konfigurieren, dass es Request-Logs an AppSignal sendet, indem Sie die CommonLogger-Middleware von Rack verwenden. Konfigurieren Sie sie wie unten gezeigt.
Überlegen Sie, ob Request-Logs nützliche Informationen für Sie enthalten; lesen Sie unseren Learning-Center-Artikel [what logs should I store](https://www.appsignal.com/learning-center/what-logs-should-i-store).
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
use Rack::CommonLogger, logger
```
#### Mehrere Logging-Backends verwenden
Um Logs sowohl an den AppSignal-Logger als auch an `STDOUT` zu senden, verwenden Sie den `.broadcast_to`-Helper unseres Loggers:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
logger.broadcast_to(Logger.new($stdout))
use Rack::CommonLogger, logger
```
### Sidekiq Logger
Sie können Sidekiq so konfigurieren, dass es seine Logs an AppSignal sendet, einschließlich der Logs, die von Ihren Hintergrundjobs ausgegeben werden:
```ruby Ruby theme={null}
Sidekiq.configure_server do |config|
config.logger = Appsignal::Logger.new("sidekiq")
config.logger.formatter = Sidekiq::Logger::Formatters::WithoutTimestamp.new
end
```
#### Mehrere Logging-Backends verwenden
Um Logs sowohl an den AppSignal-Logger als auch an `STDOUT` zu senden, verwenden Sie den `.broadcast_to`-Helper unseres Loggers:
```ruby Ruby theme={null}
Sidekiq.configure_server do |config|
config.logger = Appsignal::Logger.new("sidekiq")
config.logger.broadcast_to(Logger.new($stdout))
config.logger.formatter = Sidekiq::Logger::Formatters::WithoutTimestamp.new
end
```
### Ruby Logger
Um Logs an AppSignal zu senden, wie Sie es mit der `Logger`-Klasse von Ruby tun würden, müssen Sie eine Instanz von `Appsignal::Logger` erstellen und ihr einen `groupname` übergeben, der definiert, von wo aus Sie loggen. Wenn wir beispielsweise aus einem Helper zum Rechnungsstellen an Kunden loggen würden:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
```
#### Mehrere Logging-Backends verwenden
Um Logs sowohl an den AppSignal-Logger als auch an `STDOUT` zu senden, verwenden Sie den `.broadcast_to`-Helper unseres Loggers:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
logger.broadcast_to(Logger.new($stdout))
```
### Semantic Logger
Die [Semantic Logger](https://logger.rocketjob.io/)-Bibliothek bietet eine umfassende Logging-Lösung für Ruby- und Rails-Anwendungen.
Nachdem Sie das `semantic_logger`-Gem hinzugefügt haben, können Sie es wie folgt konfigurieren, um Logs an AppSignal zu senden:
```ruby Ruby theme={null}
appsignal_logger = Appsignal::Logger.new("rails", format: Appsignal::Logger::LOGFMT)
SemanticLogger.add_appender(logger: appsignal_logger, formatter: :logfmt)
```
#### Mehrere Logging-Backends verwenden
Um Logs sowohl an den AppSignal-Logger als auch an `STDOUT` zu senden, fügen Sie mit der Methode `add_appender` einen weiteren Appender hinzu:
```ruby Ruby theme={null}
appsignal_logger = Appsignal::Logger.new("rails", format: Appsignal::Logger::LOGFMT)
SemanticLogger.add_appender(logger: appsignal_logger, formatter: :logfmt)
SemanticLogger.add_appender(io: $stdout)
```
## Verwendung
### Logs senden
Wie bei der `Logger`-Klasse von Ruby/Rails können Sie die Severity-Stufe Ihrer Logs mit `fatal`, `error`, `warn`, `info` und `debug` definieren:
```ruby Ruby theme={null}
logger.warn("Something went wrong")
```
Sie können benutzerdefinierte Attribute definieren, um Log-Informationen zu senden, die beim Filtern und Abfragen von Logs verwendet werden können:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
logger.info("Generating invoice for customer", { customer_id: @customer.id })
invoice = generate_invoice(@customer)
logger.info("Generated invoice for customer", { customer_id: @customer.id, invoice_id: invoice.id })
```
Sie können Nachrichteninhalte und Attributwerte mit unserer [Abfragesyntax](/logging/query-syntax) abfragen und filtern.
Nach der Konfiguration werden die gewünschten Attribute als Log-Tags an AppSignal gesendet und sind in der AppSignal Logging-Oberfläche abfragbar.
### Standard-Logger-Attribute
Beim Initialisieren des AppSignal-Loggers können Sie Standardattribute angeben, die in allen Log-Nachrichten enthalten sind:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper", attributes: { customer_id: @customer.id })
```
Die beim Initialisieren des Loggers angegebenen Attribute werden in allen Log-Nachrichten enthalten sein, die von dieser Logger-Instanz gesendet werden. Mit der Log-Nachricht übergebene Attribute werden mit den Standard-Logger-Attributen zusammengeführt.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper", attributes: { customer_id: @customer.id })
# This log message will contain the `customer_id` attribute:
logger.info("Generating invoice for customer")
invoice = generate_invoice(@customer)
# This log message will contain the `customer_id` and `invoice_id` attributes:
logger.info("Generated invoice for customer", { invoice_id: invoice.id })
```
Wenn sowohl der Logger als auch die Log-Nachricht dasselbe Attribut bereitstellen, überschreibt das Attribut der Log-Nachricht das Standard-Logger-Attribut.
## Formate
### Automatisch erkanntes Format
Das AppSignal for Ruby-Gem erkennt das Format der Log-Zeile standardmäßig automatisch als JSON, Logfmt oder Plaintext und parst die Attribute daraus.
Sie müssen das Log-Format nicht manuell einstellen, es sei denn, es wird nicht ordnungsgemäß erkannt.
Bitte [benachrichtigen Sie uns](mailto:support@appsignal.com?subject=Log%20format%20auto%20detection%20not%20working) auch, wenn dies nicht automatisch funktioniert.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group")
# Plaintext format
logger.info("This is about the blog")
# Logfmt format
logger.info("category=blog This is about the blog")
# JSON format
logger.info('{"category": "blog", "message": "This is about the blog"}')
```
### Logfmt
Der AppSignal Logger kann explizit so konfiguriert werden, dass er erwartet, dass die Zeile als Logfmt formatiert ist, und Attribute daraus parst.
Verwenden Sie diese Option, wenn Sie eine ältere Version des AppSignal for Ruby-Gems verwenden, die keine [automatische Formaterkennung](#auto-detected-format) unterstützt.
Das Log-Format kann beim Erstellen eines Loggers angegeben werden.
Übergeben Sie beim Initialisieren des AppSignal-Loggers die Logfmt-Konstante in der Option `format`.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::LOGFMT)
logger.info("category=blog This is about the blog")
```
Im obigen Beispiel wird ein filterbares category-Attribut mit dem Wert "blog" geloggt.
### JSON
Der AppSignal Logger kann explizit so konfiguriert werden, dass er erwartet, dass die Zeile als JSON formatiert ist, und Attribute daraus parst.
Verwenden Sie diese Option, wenn Sie eine ältere Version des AppSignal for Ruby-Gems verwenden, die keine [automatische Formaterkennung](#auto-detected-format) unterstützt.
Das Log-Format kann beim Erstellen eines Loggers angegeben werden.
Übergeben Sie beim Initialisieren des AppSignal-Loggers die JSON-Konstante in der Option `format`.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::JSON)
logger.info('{"category": "blog", "message": "This is about the blog"}')
```
Im obigen Beispiel wird ein filterbares category-Attribut mit dem Wert "blog" geloggt.
## Logs filtern
Sie können [die Konfigurationsoption `ignore_logs`](/ruby/configuration/options#option-ignore_logs) verwenden, um Log-Zeilen zu ignorieren. Lesen Sie [unseren Leitfaden zum Ignorieren von Logs](/guides/filter-data/ignore-logs), um mehr zu erfahren.
## Brauchen Sie Hilfe?
Nachdem Sie Ihre Ruby-Anwendung so konfiguriert haben, dass sie Logs sendet, sollten die Logs in AppSignal erscheinen. Wenn Sie sich bei diesem Schritt unsicher sind oder AppSignal keine Logs empfängt, können Sie sich jederzeit für [Unterstützung an uns wenden](mailto:support@appsignal.com). Wir helfen Ihnen, wieder auf Kurs zu kommen!