;
};
Cette documentation décrit comment configurer la journalisation avec votre intégration AppSignal for Ruby.
## Configurer la journalisation
🔐 N'envoyez pas d'informations personnelles identifiables (PII) à AppSignal. Filtrez les PII (par exemple, noms, e-mails) des journaux et utilisez un identifiant, un hash ou un identifiant pseudonymisé à la place.
Pour les **entités couvertes par la HIPAA**, plus d'informations sur la signature d'un Business Associate Agreement (BAA) sont disponibles dans notre [documentation Business Add-Ons](/support/business-add-ons).
Vous n'avez pas besoin de créer une source de journaux pour envoyer des journaux depuis l'intégration AppSignal for Ruby. Une source de journaux "application" sera créée automatiquement.
### Rails Logger
Vous pouvez configurer le framework Rails pour envoyer des journaux à AppSignal dans un fichier d'initialisation comme `config/initializers/logging.rb` :
```ruby Ruby theme={null}
# config/initializers/logging.rb
appsignal_logger = Appsignal::Logger.new("rails")
Rails.logger = ActiveSupport::TaggedLogging.new(appsignal_logger)
```
#### Utiliser plusieurs backends de journalisation
Pour envoyer des journaux à la fois au logger d'AppSignal et au logger par défaut de Rails, utilisez l'helper `.broadcast_to` de notre logger :
```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)
```
Nous ne recommandons pas d'utiliser la fonctionnalité broadcast logger intégrée de Rails, en raison de problèmes de compatibilité lorsqu'elle est utilisée avec la journalisation taggée.
#### Prise en charge de la journalisation taggée
L'utilisation de `ActiveSupport::TaggedLogging` dans les exemples ci-dessus permet la prise en charge des tags de journal de Rails. Par exemple, si vous souhaitez ajouter le tag request ID aux messages de journal, ajoutez-le au tableau `config.log_tags` dans le fichier `config/application.rb` :
```ruby Ruby theme={null}
module TestApp
class Application < Rails::Application
config.log_tags = [:request_id]
end
end
```
#### Utiliser Lograge
Cette configuration Lograge ne remplace pas la configuration du logger Rails. Si vous
souhaitez signaler les journaux de `Rails.logger`, les [étapes de configuration du logger
Rails](#rails-logger) doivent également être suivies.
La bibliothèque [Lograge](https://github.com/roidrage/lograge) est une solution populaire pour l'ingestion de journaux *de requêtes* Rails structurés.
Après avoir ajouté la gem `lograge`, vous pouvez la configurer dans `config/initializers/lograge.rb` pour envoyer des journaux à AppSignal :
```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 ne prend pas en charge les niveaux de journal. Tous les journaux émis via Lograge apparaîtront
avec le niveau de sévérité `INFO` dans l'interface de journalisation AppSignal.
### Sinatra Logger
Vous pouvez configurer Sinatra pour envoyer les journaux de requêtes à AppSignal en utilisant le middleware CommonLogger de Rack. Configurez-le comme indiqué ci-dessous.
Demandez-vous si les journaux de requêtes contiennent des informations utiles pour vous, lisez notre article du learning center [quels journaux dois-je stocker](https://www.appsignal.com/learning-center/what-logs-should-i-store).
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
use Rack::CommonLogger, logger
```
#### Utiliser plusieurs backends de journalisation
Pour envoyer des journaux à la fois au logger d'AppSignal et à `STDOUT`, utilisez l'helper `.broadcast_to` de notre logger :
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
logger.broadcast_to(Logger.new($stdout))
use Rack::CommonLogger, logger
```
### Sidekiq Logger
Vous pouvez configurer Sidekiq pour envoyer ses journaux à AppSignal, y compris les journaux émis par vos jobs en arrière-plan :
```ruby Ruby theme={null}
Sidekiq.configure_server do |config|
config.logger = Appsignal::Logger.new("sidekiq")
config.logger.formatter = Sidekiq::Logger::Formatters::WithoutTimestamp.new
end
```
#### Utiliser plusieurs backends de journalisation
Pour envoyer des journaux à la fois au logger d'AppSignal et à `STDOUT`, utilisez l'helper `.broadcast_to` de notre logger :
```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
Pour envoyer des journaux à AppSignal comme vous le feriez avec la classe `Logger` de Ruby, vous devrez créer une instance de `Appsignal::Logger` et lui fournir un `groupname` qui définit d'où vous journalisez, par exemple, si nous journalisions depuis un helper pour facturer des clients :
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
```
#### Utiliser plusieurs backends de journalisation
Pour envoyer des journaux à la fois au logger d'AppSignal et à `STDOUT`, utilisez l'helper `.broadcast_to` de notre logger :
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
logger.broadcast_to(Logger.new($stdout))
```
### Semantic Logger
La bibliothèque [Semantic Logger](https://logger.rocketjob.io/) fournit une solution de journalisation complète pour les applications Ruby et Rails.
Après avoir ajouté la gem `semantic_logger`, vous pouvez la configurer pour envoyer des journaux à AppSignal comme suit :
```ruby Ruby theme={null}
appsignal_logger = Appsignal::Logger.new("rails", format: Appsignal::Logger::LOGFMT)
SemanticLogger.add_appender(logger: appsignal_logger, formatter: :logfmt)
```
#### Utiliser plusieurs backends de journalisation
Pour envoyer des journaux à la fois au logger d'AppSignal et à `STDOUT`, ajoutez un autre appender en utilisant la méthode `add_appender` :
```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)
```
## Utilisation
### Envoi de journaux
Comme la classe `Logger` de Ruby/Rails, vous pouvez définir le niveau de sévérité de vos journaux en utilisant `fatal`, `error`, `warn`, `info` et `debug` :
```ruby Ruby theme={null}
logger.warn("Something went wrong")
```
Vous pouvez définir des attributs personnalisés pour envoyer des informations de journal qui peuvent être utilisées lors du filtrage et de l'interrogation des journaux :
```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 })
```
Vous pouvez interroger et filtrer le contenu des messages et les valeurs d'attribut en utilisant notre [syntaxe de requête](/logging/query-syntax).
Une fois configurés, les attributs souhaités seront envoyés à AppSignal en tant que tags de journal, et seront interrogeables dans l'interface de journalisation d'AppSignal.
### Attributs par défaut du logger
Lors de l'initialisation du logger AppSignal, vous pouvez fournir des attributs par défaut qui seront inclus dans tous les messages de journal :
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper", attributes: { customer_id: @customer.id })
```
Les attributs fournis lors de l'initialisation du logger seront inclus dans tous les messages de journal envoyés depuis cette instance de logger. Les attributs fournis avec le message de journal seront fusionnés avec les attributs par défaut du logger.
```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 })
```
Lorsque le logger et le message de journal fournissent tous deux le même attribut, l'attribut du message de journal remplacera l'attribut par défaut du logger.
## Formats
### Format détecté automatiquement
La gem AppSignal for Ruby détectera automatiquement le format de la ligne de journal comme JSON, Logfmt ou plaintext par défaut, et en analysera les attributs.
Vous n'avez pas besoin de définir manuellement le format du journal, sauf s'il n'est pas correctement détecté.
Veuillez également [nous le signaler](mailto:support@appsignal.com?subject=Log%20format%20auto%20detection%20not%20working) si cela ne fonctionne pas automatiquement.
```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
Le logger AppSignal peut être configuré explicitement pour attendre que la ligne soit formatée en Logfmt et en analyser les attributs.
Utilisez cette option lorsque vous utilisez une version plus ancienne de la gem AppSignal for Ruby, qui ne prend pas en charge la [détection automatique du format](#auto-detected-format).
Le format de journal peut être spécifié lors de la création d'un logger.
Lors de l'initialisation du logger AppSignal, passez la constante Logfmt dans l'option format.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::LOGFMT)
logger.info("category=blog This is about the blog")
```
Dans l'exemple ci-dessus, un attribut category filtrable avec la valeur "blog" sera enregistré.
### JSON
Le logger AppSignal peut être configuré explicitement pour attendre que la ligne soit formatée en JSON et en analyser les attributs.
Utilisez cette option lorsque vous utilisez une version plus ancienne de la gem AppSignal for Ruby, qui ne prend pas en charge la [détection automatique du format](#auto-detected-format).
Le format de journal peut être spécifié lors de la création d'un logger.
Lors de l'initialisation du logger AppSignal, passez la constante JSON dans l'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"}')
```
Dans l'exemple ci-dessus, un attribut category filtrable avec la valeur "blog" sera enregistré.
## Filtrage des journaux
Vous pouvez utiliser [l'option de configuration `ignore_logs`](/ruby/configuration/options#option-ignore_logs) pour ignorer les lignes de journal. Consultez [notre guide Ignore Logs](/guides/filter-data/ignore-logs) pour en savoir plus.
## Besoin d'aide ?
Après avoir configuré votre application Ruby pour envoyer des journaux, les journaux devraient apparaître dans AppSignal. Si vous avez des doutes sur cette étape ou si AppSignal ne reçoit aucun journal, vous pouvez toujours [nous contacter](mailto:support@appsignal.com) pour obtenir de l'aide. Nous vous aiderons à remettre les choses sur la bonne voie !