;
};
This documentation outlines how to configure logging with your AppSignal for Ruby integration.
## Configure Logging
🔐 Do not send Personal Identifiable Information (PII) to AppSignal. Filter PII (e.g., names, emails) from logs and use an ID, hash, or pseudonymized identifier instead.
For **HIPAA-covered entities**, more information about signing a Business Associate Agreement (BAA) can be found in our [Business Add-Ons documentation](/support/business-add-ons).
You do not need to create a log source to send logs from the AppSignal for Ruby integration. An "application" log source will be created automatically.
### Rails Logger
You can configure the Rails framework to send logs to AppSignal in an initializer file like `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)
```
#### Using multiple logging backends
To send logs to both AppSignal's logger and Rails' default logger, use our logger's `.broadcast_to` helper:
```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)
```
We do not recommend using Rails' built-in broadcast logger feature, due to compatibility issues when used alongside tagged logging.
#### Tagged logging support
The use of `ActiveSupport::TaggedLogging` in the above examples enables support for Rails' log tags. For example, if you wish to add the request ID tag to the log messages, add it to the `config.log_tags` array in the `config/application.rb` file:
```ruby Ruby theme={null}
module TestApp
class Application < Rails::Application
config.log_tags = [:request_id]
end
end
```
#### Using Lograge
This Lograge config is not a replacement for the Rails logger config. If you
want to report logs from `Rails.logger`, the [Rails logger config
steps](#rails-logger) also need to be followed.
The [Lograge](https://github.com/roidrage/lograge) library is a popular solution for ingesting structured Rails *request* logs.
After adding the `lograge` gem, you can configure it in `config/initializers/lograge.rb` to send logs to 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 does not support log levels. All logs emitted via Lograge will appear
with severity level `INFO` in the AppSignal Logging UI.
### Sinatra Logger
You can configure Sinatra to send request logs to AppSignal using Rack's CommonLogger middleware. Configure it like shown below.
Consider if request logs contain useful information for you, read our [what logs should I store](https://www.appsignal.com/learning-center/what-logs-should-i-store) learning center article.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
use Rack::CommonLogger, logger
```
#### Using multiple logging backends
To send logs to both AppSignal's logger and `STDOUT`, use our logger's `.broadcast_to` helper:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("sinatra")
logger.broadcast_to(Logger.new($stdout))
use Rack::CommonLogger, logger
```
### Sidekiq Logger
You can configure Sidekiq to send its logs to AppSignal, including the logs emitted by your background jobs:
```ruby Ruby theme={null}
Sidekiq.configure_server do |config|
config.logger = Appsignal::Logger.new("sidekiq")
config.logger.formatter = Sidekiq::Logger::Formatters::WithoutTimestamp.new
end
```
#### Using multiple logging backends
To send logs to both AppSignal's logger and `STDOUT`, use our logger's `.broadcast_to` helper:
```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
To send logs to AppSignal as you would with Ruby's `Logger` class, you will need to create an instance of `Appsignal::Logger` and provide it with a `groupname` that defines where you are logging from, for example, if we were logging from a helper for invoicing clients:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
```
#### Using multiple logging backends
To send logs to both AppSignal's logger and `STDOUT`, use our logger's `.broadcast_to` helper:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper")
logger.broadcast_to(Logger.new($stdout))
```
### Semantic Logger
The [Semantic Logger](https://logger.rocketjob.io/) library provides a comprehensive logging solution for Ruby and Rails applications.
After adding the `semantic_logger` gem, you can configure it to send logs to AppSignal as follows:
```ruby Ruby theme={null}
appsignal_logger = Appsignal::Logger.new("rails", format: Appsignal::Logger::LOGFMT)
SemanticLogger.add_appender(logger: appsignal_logger, formatter: :logfmt)
```
#### Using multiple logging backends
To send logs to both AppSignal's logger and `STDOUT`, add another appender using the `add_appender` method:
```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)
```
## Usage
### Sending Logs
Like the Ruby/Rails `Logger` class, you can define the severity level of your logs by using `fatal`, `error`, `warn`, `info`, and `debug`:
```ruby Ruby theme={null}
logger.warn("Something went wrong")
```
You can define custom attributes to send log information that can be used when filtering and querying 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 })
```
You can query and filter on message contents and attribute values using our [query syntax](/logging/query-syntax).
Once configured, the desired attributes will be sent to AppSignal as log tags, and be queryable in the AppSignal logging interface.
### Default Logger Attributes
When initializing the AppSignal logger, you can provide default attributes that will be included in all log messages:
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("invoice_helper", attributes: { customer_id: @customer.id })
```
The attributes provided when initializing the logger will be included in all log messages sent from that logger instance. Attributes provided with the log message will be merged with the default logger attributes.
```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 })
```
When both the logger and the log message provide the same attribute, the log message's attribute will override the default logger attribute.
## Formats
### Auto detected format
The AppSignal for Ruby gem will automatically detect the log line's format as JSON, Logfmt or plaintext by default, and parse attributes from it.
You don't need to manually set the log format, unless it's not being detected properly.
Please also [notify us](mailto:support@appsignal.com?subject=Log%20format%20auto%20detection%20not%20working) if this isn't working automatically.
```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
The AppSignal Logger can be explicitly configured to expect the line to be formatted as Logfmt and parse attributes from it.
Use this option when using an older AppSignal for Ruby gem version, which does not support [automatic format detection](#auto-detected-format).
The log format can be specified when creating a logger.
When initializing the AppSignal logger pass the Logfmt constant in the format option.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::LOGFMT)
logger.info("category=blog This is about the blog")
```
In the example above, a filterable category attribute with the value "blog" will be logged.
### JSON
The AppSignal Logger can be explicitly configured to expect the line to be formatted as JSON and parse attributes from it.
Use this option when using an older AppSignal for Ruby gem version, which does not support [automatic format detection](#auto-detected-format).
The log format can be specified when creating a logger.
When initializing the AppSignal logger pass the JSON constant in the format option.
```ruby Ruby theme={null}
logger = Appsignal::Logger.new("group", format: Appsignal::Logger::JSON)
logger.info('{"category": "blog", "message": "This is about the blog"}')
```
In the example above, a filterable category attribute with the value "blog" will be logged.
## Filtering Logs
You can use [the `ignore_logs` configuration option](/ruby/configuration/options#option-ignore_logs) to ignore log lines. See [our Ignore Logs guide](/guides/filter-data/ignore-logs) to learn more.
## Need Help?
After configuring your Ruby application to send logs, logs should appear in AppSignal. If you are unsure about this step or AppSignal is not receiving any logs, you can always [reach out](mailto:support@appsignal.com) for assistance. We'll help get you back on track!