Explore documentation
  1. Welcome to Telemetry 👋
  2. Quick start guide
  3. Wide events vs. time series
  4. Ingesting data
    1. Better Stack collector
    2. Vector
    3. OpenTelemetry
    4. Ingesting via HTTP API
    5. Ingesting metrics
    6. Ingesting logs
      1. Docker & Kubernetes
      2. Operating systems
      3. Log forwarders
      4. Programming languages
        1. JavaScript & Node.js
        2. Python
        3. Ruby
        4. PHP
        5. Java
        6. .NET
        7. Go
        8. Erlang
      5. Cloud platforms
      6. Web servers & Load balancers
      7. Databases & queues
      8. Storage
    7. Migrating to Better Stack
  5. Using the product
    1. Transforming ingested data
    2. Querying data
    3. Tracing
    4. Alerts
  6. Telemetry API
    1. Getting an API token
    2. Sources API
    3. Source groups API
    4. Metrics API
    5. Connections API
    6. Query API ↗
  7. Alternative to
    1. Lightstep

Better Stack Ruby & Rails logging

Where do you want to collect your Ruby logs from?

Logging from Rails

Collect logs from your Rails application, including your Sidekiq jobs. This integration also supports Structured Events in Rails 8.1 or higher for rich, queryable event logging.

1. Install

Install Better Stack Rails Gem:

Add Better Stack Rails Gem
bundle add logtail-rails

2. Setup

Set up Better Stack Rails Gem in config/application.rb:

config/application.rb
module YourProject
  class Application < Rails::Application
    # ...
    # configuration of your project
    # ...

    config.logger = Logtail::Logger.create_default_logger(
      "$SOURCE_TOKEN",
      ingesting_host: "$INGESTING_HOST",
    )
  end
end


3. Start logging 🎉

Use Rails logger as usual:

Send logs to Better Stack
Rails.logger.error("Something bad happened.")
Rails.logger.warn("Log message with structured logging.", {
    item: "Orange Soda",
    price: 100.00
})

# Send a structured event (in Rails 8.1 or higher)
Rails.event.notify("user.signed_up", email: "user@example.com")

You should see your logs in Better Stack Logs → Live tail.

Check out the Ruby on Rails dashboard.

Rails version 5.0 or higher is required.
Ruby version 2.5 or higher is required.

Logging from Rack

Collect logs from any Rack-based framework such as Sinatra, Hanami, Padrino, or Roda.

1. Install

Install Better Stack Rack Gem:

Add Better Stack Rack Gem
bundle add logtail-rack

2. Setup

Set up Better Stack Rack Gem in your config.ru:

config.ru
require 'logtail-rack'

# Initialization of logging middlewares (you don't have to use all)
use Logtail::Integrations::Rack::HTTPContext
use Logtail::Integrations::Rack::HTTPEvents
use Logtail::Integrations::Rack::ErrorEvent
use Logtail::Integrations::Rack::UserContext
use Logtail::Integrations::Rack::SessionContext

# Logger instance initialization
http_io_device = Logtail::LogDevices::HTTP.new(
  "$SOURCE_TOKEN",
  ingesting_host: "$INGESTING_HOST",
)
logger = Logtail::Logger.new(http_io_device)
Logtail::Config.instance.logger = logger

# Here is your application initialization
run ...


3. Start logging 🎉

Use the instantiated logger instance to send logs to Better Stack:

Send logs to Better Stack
logger = Logtail::Config.instance.logger

logger.info("I am using Better Stack! 🚀")

# You can also provide additional information when logging
logger.debug("Logging structured data...",
  name: {
    first: "John",
    last: "Smith"
  },
  id: 123456
)

You should see your logs in Better Stack Logs → Live tail.

Rack version 1.2 or higher is required.
Ruby version 2.3 or higher is required.

Logging from Ruby

Collect logs from your Ruby code.

1. Install

Install Better Stack Gem:

Add Better Stack Gem
bundle add logtail

2. Setup

Set up Better Stack Ruby client:

Create Better Stack logger
require "logtail"

http_io_device = Logtail::LogDevices::HTTP.new(
  "$SOURCE_TOKEN",
  ingesting_host: "$INGESTING_HOST",
)
logger = Logtail::Logger.new(http_io_device)


3. Start logging 🎉

Use Ruby logger as usual:

Send logs to Better Stack
logger.error("Something bad happened.")
logger.warn("Log message with structured logging.", {
    item: "Orange Soda",
    price: 100.00
})

# Close logger to ensure that all logs are sent to Better Stack
logger.close

You should see your logs in Better Stack → Live tail.

Ruby version 2.3.0 or higher is required.

Need help?

Please let us know at hello@betterstack.com.
We're happy to help! 🙏

Example projects

You can take a look at example projects on Github:

Additional information

Interested in learning more about log levels in Rails?
Check out our Intro guide to Ruby on Rails logging.

Enrich log context

Add custom data to multiple log lines using with block:

Rails Rack Ruby 
Logtail.with_context(user: { id: 123 }) do
    Rails.logger.info('User logged in.')
    Rails.logger.info('User bought a gem.')
end
logger = Logtail::Config.instance.logger
Logtail.with_context(user: { id: 123 }) do
    logger.info('User logged in.')
    logger.info('User bought a gem.')
end
Logtail.with_context(user: { id: 123 }) do
    logger.info('User logged in.')
    logger.info('User bought a gem.')
end

Filter sensitive information

In Rails or Rack, you can filter sensitive parameters and HTTP headers:

Rails Rack 
# config/initializers/filter_logging.rb
# Be sure to restart your server when you create this file.

# Configure parameters to be filtered from the log file.
# Use this to limit dissemination of sensitive information.
# See the ActiveSupport::ParameterFilter documentation for supported notations and behaviors.
Rails.application.config.filter_parameters += [
  :passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
]

# Configure HTTP headers to be filtered from the log.
# Use this to limit dissemination of sensitive information.
Logtail::Integrations::Rack::HTTPEvents.http_header_filters = [
  :authorization, :proxy_authorization, :cookie
]
# config.ru
# Be sure to restart your server when you modify this file.

# Configure HTTP headers to be filtered from the log.
# Use this to limit dissemination of sensitive information.
Logtail::Integrations::Rack::HTTPEvents.http_header_filters = [
  :authorization, :proxy_authorization, :cookie
]

Filter logs sent to Better Stack

You can prevent logger from sending certain logs to Better Stack:

Rails Rack Ruby 
# in your config/application.rb
config.logtail.filter_sent_to_better_stack do |log_entry|
    log_entry.context_snapshot[:http][:path].start_with?('/_')
end
# in your config.ru
Logtail.config.filter_sent_to_better_stack do |log_entry|
    log_entry.message.include?("IGNORE")
end
# anywhere before sending the logs
Logtail.config.filter_sent_to_better_stack do |log_entry|
    log_entry.message.include?("IGNORE")
end

See Logtail::LogEntry for available attributes of the block parameter.

Structured Events

Starting with Rails 8.1, you can use the new Structured Events system to send structured data to Better Stack. The logtail-rails gem automatically subscribes to these events and logs them as structured log entries in case you've used Logtail::Logger.create_default_logger to initialize.

This is particularly useful for tracking key business events or application-specific actions with rich, queryable data, without having to format them into a log message.

Using events Configuring the event subscription 
# Notify about a simple event with a payload
Rails.event.notify("user.signed_up",  email: "user@example.com")

# You can add context that will be included in all subsequent events
Rails.event.set_context(request_id: "abc-123", shop_id: 456)

# Tag specific events for easier filtering
Rails.event.tagged("api", "billing") do
    Rails.event.notify("payment.processed", amount: 9.99, currency: "USD")
end
# If you haven't used Logtail::Logger.create_default_logger
# the logger needs to be subscribed manually to the events
Rails.event.subscribe(
  Logtail::Integrations::Rails::EventLogSubscriber.new(logger)
)

# The event subscriber can have the log level changed
Logtail::Integrations::Rails::EventLogSubscriber.log_level = :debug

# The event subscriber can be disabled
Logtail::Integrations::Rails::EventLogSubscriber.enabled = false

When you use Rails.event.notify, the logtail-rails gem captures the event name, payload, context, tags, and source location, and sends it all as a structured log to Better Stack.

Previous article

Better Stack Python logging

Next article

Better Stack PHP logging