Ruby & Rails

gem install opentelemetry-sdk \
  opentelemetry-exporter-otlp \
  opentelemetry-instrumentation-all

gem "opentelemetry-sdk"
gem "opentelemetry-exporter-otlp"
gem "opentelemetry-instrumentation-all"

require "opentelemetry/sdk"
require "opentelemetry/exporter/otlp"
require "opentelemetry/instrumentation/all"

OpenTelemetry::SDK.configure do |c|
  c.service_name = "my-rails-app"
  c.use_all # Auto-instrument Rails, ActiveRecord, Net::HTTP, etc.
end

export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.squasher.ai
export OTEL_EXPORTER_OTLP_HEADERS="x-squasher-key=sq_pk_your_api_key"
export OTEL_SERVICE_NAME=my-rails-app

rails server

# config/initializers/squasher.rb
class SquasherErrorSubscriber
  ENDPOINT = "https://ingest.squasher.ai/v1/ingest/#{ENV['SQUASHER_PROJECT_ID']}"

  def report(error, handled:, severity:, context: {}, source: nil)
    Net::HTTP.post(
      URI(ENDPOINT),
      {
        message: error.message,
        type: error.class.name,
        level: severity.to_s == "error" ? "error" : "warning",
        stack: error.backtrace&.join("\n"),
        environment: Rails.env,
        tags: context.transform_values(&:to_s),
      }.to_json,
      "Content-Type" => "application/json",
      "x-squasher-key" => ENV["SQUASHER_API_KEY"],
    )
  rescue StandardError
    # Don't let reporting failures crash the app
  end
end

Rails.error.subscribe(SquasherErrorSubscriber.new)

require "net/http"
require "json"

module Squasher
  ENDPOINT = URI("https://ingest.squasher.ai/v1/ingest/#{ENV['SQUASHER_PROJECT_ID']}")
  API_KEY = ENV["SQUASHER_API_KEY"]

  def self.capture_error(error, tags: {})
    payload = {
      message: error.message,
      type: error.class.name,
      level: "error",
      stack: error.backtrace&.join("\n"),
      environment: ENV.fetch("RAILS_ENV", "production"),
      tags: tags.transform_values(&:to_s),
    }

    Thread.new do
      req = Net::HTTP::Post.new(ENDPOINT)
      req["Content-Type"] = "application/json"
      req["x-squasher-key"] = API_KEY
      req.body = payload.to_json
      Net::HTTP.start(ENDPOINT.hostname, ENDPOINT.port, use_ssl: true) do |http|
        http.request(req)
      end
    rescue StandardError
      # Silently fail
    end
  end

  def self.log(level, message, tags: {})
    payload = {
      message: message,
      level: level.to_s,
      tags: tags.transform_values(&:to_s),
    }

    Thread.new do
      req = Net::HTTP::Post.new(ENDPOINT)
      req["Content-Type"] = "application/json"
      req["x-squasher-key"] = API_KEY
      req.body = payload.to_json
      Net::HTTP.start(ENDPOINT.hostname, ENDPOINT.port, use_ssl: true) do |http|
        http.request(req)
      end
    rescue StandardError
      # Silently fail
    end
  end
end

begin
  process_payment(order)
rescue => e
  Squasher.capture_error(e, tags: { order_id: order.id, amount: order.total })
  raise
end

Squasher.log(:info, "Deployment completed", tags: { version: "v1.2.3" })

gem install opentelemetry-instrumentation-sinatra

require "opentelemetry/instrumentation/sinatra"

OpenTelemetry::SDK.configure do |c|
  c.use "OpenTelemetry::Instrumentation::Sinatra"
end

For Ruby or Rails, prefer OpenTelemetry auto-instrumentation first. Use direct HTTP only for small custom hooks, keep keys in env, verify one Rails.error or exception path, and flush any queued work before shutdown when applicable.