;
};
Esta documentação descreve como configurar o logging com sua integração AppSignal for Ruby.
## Configurar logging
🔐 Não envie Informações Pessoais Identificáveis (PII) para a AppSignal. Filtre PII (por exemplo, nomes, e-mails) dos logs e use um ID, hash ou identificador pseudonimizado no lugar.
Para **entidades cobertas pela HIPAA**, mais informações sobre como assinar um Business Associate Agreement (BAA) podem ser encontradas em nossa [documentação de Business Add-Ons](/support/business-add-ons).
Você não precisa criar uma fonte de log para enviar logs da integração AppSignal for Ruby. Uma fonte de log "application" será criada automaticamente.
### Rails Logger
Você pode configurar o framework Rails para enviar logs ao AppSignal em um arquivo de inicializador como `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)
```
#### Usando múltiplos backends de logging
Para enviar logs tanto para o logger do AppSignal quanto para o logger padrão do Rails, use o helper `.broadcast_to` do nosso 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)
```
Não recomendamos usar o recurso broadcast logger embutido do Rails, devido a problemas de compatibilidade quando usado junto com tagged logging.
#### Suporte a tagged logging
O uso de `ActiveSupport::TaggedLogging` nos exemplos acima habilita o suporte às tags de log do Rails. Por exemplo, se você quiser adicionar a tag request ID às mensagens de log, adicione-a ao array `config.log_tags` no arquivo `config/application.rb`:
```ruby Ruby theme={null}
module TestApp
class Application < Rails::Application
config.log_tags = [:request_id]
end
end
```
#### Usando o Lograge
Esta configuração do Lograge não substitui a configuração do logger do Rails.
Se você quiser reportar logs do `Rails.logger`, os [passos de configuração do
Rails logger](#rails-logger) também precisam ser seguidos.
A biblioteca [Lograge](https://github.com/roidrage/lograge) é uma solução popular para ingerir logs estruturados de *requisições* do Rails.
Depois de adicionar a gem `lograge`, você pode configurá-la em `config/initializers/lograge.rb` para enviar logs ao 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
```
O Lograge não suporta níveis de log. Todos os logs emitidos via Lograge irão
aparecer com nível de severidade `INFO` na interface de Logging do AppSignal.
### Sinatra Logger
Você pode configurar o Sinatra para enviar logs de requisições ao AppSignal usando o middleware CommonLogger do Rack. Configure-o como mostrado abaixo.
Considere se os logs de requisições contêm informações úteis para você, leia nosso artigo do learning center [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
```
#### Usando múltiplos backends de logging
Para enviar logs tanto para o logger do AppSignal quanto para o `STDOUT`, use o helper `.broadcast_to` do nosso logger:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
logger.broadcast_to(Logger.new($stdout))
use Rack::CommonLogger, logger
```
### Sidekiq Logger
Você pode configurar o Sidekiq para enviar seus logs ao AppSignal, incluindo os logs emitidos pelos seus jobs em segundo plano:
```ruby Ruby theme={null}
Sidekiq.configure_server do |config|
config.logger = Appsignal::Logger.new("sidekiq")
config.logger.formatter = Sidekiq::Logger::Formatters::WithoutTimestamp.new
end
```
#### Usando múltiplos backends de logging
Para enviar logs tanto para o logger do AppSignal quanto para o `STDOUT`, use o helper `.broadcast_to` do nosso 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
Para enviar logs ao AppSignal como você faria com a classe `Logger` do Ruby, você precisa criar uma instância de `Appsignal::Logger` e fornecer um `groupname` que define de onde você está fazendo o log. Por exemplo, se estivéssemos fazendo log a partir de um helper para faturamento de clientes:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
```
#### Usando múltiplos backends de logging
Para enviar logs tanto para o logger do AppSignal quanto para o `STDOUT`, use o helper `.broadcast_to` do nosso logger:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
logger.broadcast_to(Logger.new($stdout))
```
### Semantic Logger
A biblioteca [Semantic Logger](https://logger.rocketjob.io/) fornece uma solução abrangente de logging para aplicações Ruby e Rails.
Depois de adicionar a gem `semantic_logger`, você pode configurá-la para enviar logs ao AppSignal da seguinte maneira:
```ruby Ruby theme={null}
appsignal_logger = Appsignal::Logger.new("rails", format: Appsignal::Logger::LOGFMT)
SemanticLogger.add_appender(logger: appsignal_logger, formatter: :logfmt)
```
#### Usando múltiplos backends de logging
Para enviar logs tanto para o logger do AppSignal quanto para o `STDOUT`, adicione outro appender usando o método `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)
```
## Uso
### Enviando logs
Assim como a classe `Logger` do Ruby/Rails, você pode definir o nível de severidade dos seus logs usando `fatal`, `error`, `warn`, `info` e `debug`:
```ruby Ruby theme={null}
logger.warn("Something went wrong")
```
Você pode definir atributos personalizados para enviar informações de log que podem ser usadas ao filtrar e consultar logs:
```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 })
```
Você pode consultar e filtrar pelo conteúdo da mensagem e pelos valores dos atributos usando nossa [sintaxe de consulta](/logging/query-syntax).
Uma vez configurados, os atributos desejados serão enviados ao AppSignal como tags de log e poderão ser consultados na interface de logging do AppSignal.
### Atributos padrão do logger
Ao inicializar o AppSignal logger, você pode fornecer atributos padrão que serão incluídos em todas as mensagens de log:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper", attributes: { customer_id: @customer.id })
```
Os atributos fornecidos na inicialização do logger serão incluídos em todas as mensagens de log enviadas por essa instância do logger. Os atributos fornecidos junto com a mensagem de log serão mesclados com os atributos padrão do 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 })
```
Quando o logger e a mensagem de log fornecem o mesmo atributo, o atributo da mensagem de log irá sobrescrever o atributo padrão do logger.
## Formatos
### Formato detectado automaticamente
A gem AppSignal for Ruby vai detectar automaticamente o formato da linha de log como JSON, Logfmt ou plaintext por padrão, e fará o parsing dos atributos a partir disso.
Você não precisa definir manualmente o formato do log, a não ser que ele não esteja sendo detectado corretamente.
Por favor, também [nos avise](mailto:support@appsignal.com?subject=Log%20format%20auto%20detection%20not%20working) se isso não estiver funcionando automaticamente.
```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
O AppSignal Logger pode ser configurado explicitamente para esperar que a linha esteja formatada como Logfmt e fazer o parsing dos atributos a partir dela.
Use essa opção quando estiver usando uma versão mais antiga da gem AppSignal for Ruby, que não suporta a [detecção automática de formato](#auto-detected-format).
O formato de log pode ser especificado ao criar um logger.
Ao inicializar o AppSignal logger, passe a constante Logfmt na opção format.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::LOGFMT)
logger.info("category=blog This is about the blog")
```
No exemplo acima, um atributo filtrável category com o valor "blog" será registrado.
### JSON
O AppSignal Logger pode ser configurado explicitamente para esperar que a linha esteja formatada como JSON e fazer o parsing dos atributos a partir dela.
Use essa opção quando estiver usando uma versão mais antiga da gem AppSignal for Ruby, que não suporta a [detecção automática de formato](#auto-detected-format).
O formato de log pode ser especificado ao criar um logger.
Ao inicializar o AppSignal logger, passe a constante JSON na opção format.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::JSON)
logger.info('{"category": "blog", "message": "This is about the blog"}')
```
No exemplo acima, um atributo filtrável category com o valor "blog" será registrado.
## Filtrando logs
Você pode usar a [opção de configuração `ignore_logs`](/ruby/configuration/options#option-ignore_logs) para ignorar linhas de log. Veja [nosso guia Ignore Logs](/guides/filter-data/ignore-logs) para saber mais.
## Precisa de ajuda?
Depois de configurar sua aplicação Ruby para enviar logs, os logs devem aparecer no AppSignal. Se você tiver dúvidas sobre este passo ou o AppSignal não estiver recebendo logs, você sempre pode [entrar em contato](mailto:support@appsignal.com) para obter ajuda. Vamos te ajudar a voltar ao normal!