lens-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3feb70c30ca8f978b2de8669531cb66b22e2d4d019b711e1ed4aaf744743006
+  data.tar.gz: 44e46c8d29db7456d1b622f97d5c1df6256e142994b32d82059bfb8ca23b33d2
+SHA512:
+  metadata.gz: 0b8ac809f6c4383c19ccac2bcf44870051d936eb9fe7d93f73660f57455493412c16bf6db964d2f074014ce9f7bb9b06d4d7ed13656d83c94d752cee26781e4c
+  data.tar.gz: ef5d900a3f546f8428d96bf679f11577871a93c83b335e315d1550c3b5ca0c7ecb353215b461858ea5467eb5a0a61ad3284687edeea6b76946d590f8bb75b939

data/README.md

@@ -0,0 +1,85 @@
+# lens-rails
+
+Zero-config APM integration for [Lens](https://github.com/gustech/lens). Drop this gem into any Rails app and logs, metrics, and request traces start flowing to your Lens instance automatically — no OpenTelemetry SDK, no protobuf, no additional processes.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lens-rails'
+```
+
+Set two environment variables (e.g. in `.env` or your secrets manager):
+
+```
+LENS_URL=https://lens.example.com
+LENS_APP_TOKEN=your-app-token
+```
+
+That's it. No initializer required.
+
+## What gets collected automatically
+
+| Signal | Source | Detail |
+|---|---|---|
+| **Logs** | `Rails.logger` | Every log line with severity, body, controller, action, and request ID |
+| **Metrics** | Rack middleware | Request count, error count, mean/p50/p95 duration — flushed every 30 s |
+| **HTTP requests** | `process_action.action_controller` | Controller, action, method, path, status, duration, SQL summary, operation waterfall |
+| **Background jobs** | `perform.active_job` | Job class, queue, duration, SQL summary, operation waterfall |
+
+Each HTTP request and job record includes a flat **operation waterfall**: one entry per SQL query (name + SQL text + duration + offset from request start) and per view render.
+
+## Configuration
+
+To override defaults, add an initializer:
+
+```ruby
+# config/initializers/lens.rb
+Lens::Rails.configure do |config|
+  config.service_name = "my-app"        # defaults to Rails app module name
+  config.url          = "https://..."   # overrides LENS_URL
+  config.app_token    = "tok_..."       # overrides LENS_APP_TOKEN
+
+  # Only record SQL queries that took at least this long (ms). Default: 0.0 (all queries).
+  config.sql_threshold_ms = 5.0
+
+  # Drop SQL queries whose text matches any of these patterns.
+  # Useful for suppressing framework noise from the waterfall.
+  config.sql_ignore = [
+    /solid_queue/i,
+    /\ASELECT.*schema_migrations/i,
+  ]
+
+  # Minimum severity to export. Default: Logger::INFO (drops DEBUG-level SQL noise).
+  # Set to Logger::WARN to export only warnings and above.
+  config.min_log_severity = Logger::INFO
+
+  # Ring-buffer size for log records (drop-oldest when full). Default: 10_000.
+  config.max_log_buffer = 10_000
+
+  # HTTP timeout for each exporter flush call (seconds). Default: 2.
+  config.exporter_open_timeout = 2
+  config.exporter_read_timeout = 2
+
+  # Maximum time to wait for a final flush on process shutdown (seconds). Default: 5.
+  config.shutdown_timeout = 5
+end
+```
+
+## How it works
+
+The gem wires up three components via a Railtie:
+
+- **`LogExporter`** — broadcasts into `Rails.logger` and batches records to `POST /v1/logs` every 5 s.
+- **`MetricsExporter`** — Rack middleware that tracks request durations via reservoir sampling and flushes to `POST /v1/metrics` every 30 s.
+- **`RequestsExporter`** — subscribes to `ActiveSupport::Notifications` (`process_action`, `sql.active_record`, `render_template`, `perform.active_job`) and flushes request and job records to `POST /v1/requests` every 30 s.
+
+All payloads are gzip-compressed JSON. Background flush threads restart automatically after a Puma or Unicorn fork.
+
+SolidQueue dispatcher jobs are filtered out of the job waterfall automatically.
+
+## Requirements
+
+- Ruby >= 3.1
+- Rails >= 7.1

data/lib/lens/rails/backoff_loop.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lens
+  module Rails
+    # Supervised sleep/call loop for flush threads.
+    #
+    # - Rescues StandardError (not Exception — we must not swallow Interrupt /
+    #   SystemExit, which would defeat the bounded at_exit flush).
+    # - On failure, doubles the sleep interval up to `max`. Resets to `base` on
+    #   the next successful call.
+    # - Sets a thread name and enables report_on_exception so a truly fatal
+    #   error is visible instead of silently killing telemetry.
+    class BackoffLoop
+      def initialize(base:, max: 60, name: "lens-loop")
+        @base = base
+        @max = max
+        @name = name
+      end
+
+      def start(&block)
+        Thread.new do
+          Thread.current.name = @name
+          Thread.current.report_on_exception = true
+          current = @base
+          loop do
+            sleep(current)
+            begin
+              block.call
+              current = @base
+            rescue => e
+              warn "#{@name}: #{e.class}: #{e.message}"
+              current = [current * 2, @max].min
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lens/rails/configuration.rb

@@ -0,0 +1,34 @@
+module Lens
+  module Rails
+    class Configuration
+      attr_accessor :url, :app_token, :service_name,
+        :max_log_buffer, :min_log_severity,
+        :sql_threshold_ms, :sql_ignore,
+        :exporter_open_timeout, :exporter_read_timeout,
+        :shutdown_timeout
+
+      def initialize
+        @url = ENV["LENS_URL"]
+        @app_token = ENV["LENS_APP_TOKEN"]
+        @service_name = ENV.fetch("LENS_SERVICE_NAME") { default_service_name }
+        @max_log_buffer = 10_000
+        @min_log_severity = ::Logger::INFO
+        @sql_threshold_ms = 0.0
+        @sql_ignore = []
+        @exporter_open_timeout = 2
+        @exporter_read_timeout = 2
+        @shutdown_timeout = 5
+      end
+
+      def configured?
+        !url.to_s.empty? && !app_token.to_s.empty?
+      end
+
+      private
+
+      def default_service_name
+        defined?(::Rails) ? ::Rails.application.class.module_parent_name.underscore : "app"
+      end
+    end
+  end
+end

data/lib/lens/rails/log_exporter.rb

@@ -0,0 +1,122 @@
+require "net/http"
+require "json"
+require "zlib"
+require "lens/rails/backoff_loop"
+
+module Lens
+  module Rails
+    # Logger sink that batches log records and ships them to Lens via POST /v1/logs.
+    # Wired into Rails.logger via broadcast in the Railtie.
+    class LogExporter < ::Logger
+      SEVERITY_TEXT = {
+        ::Logger::DEBUG => "DEBUG",
+        ::Logger::INFO => "INFO",
+        ::Logger::WARN => "WARN",
+        ::Logger::ERROR => "ERROR",
+        ::Logger::FATAL => "FATAL",
+        ::Logger::UNKNOWN => "UNKNOWN"
+      }.freeze
+
+      DROP_WARN_INTERVAL = 60.0
+
+      def initialize(url:, token:, service_name:,
+        max_buffer: 10_000,
+        min_severity: ::Logger::INFO,
+        open_timeout: 2,
+        read_timeout: 2)
+        super(File::NULL)
+        @token = token
+        @service_name = service_name
+        @uri = URI("#{url}/v1/logs")
+        @max_buffer = max_buffer
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @min_severity = min_severity
+        @buffer = []
+        @dropped = 0
+        @last_drop_warn_at = 0.0
+        @mutex = Mutex.new
+        restart_flush_thread
+        Lens::Rails.register_flushable(self)
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        return true if Thread.current[:lens_in_export]
+
+        severity ||= ::Logger::UNKNOWN
+        return true if severity < @min_severity
+
+        message = block ? block.call : progname if message.nil?
+        return true if message.nil?
+
+        record = {
+          timestamp: Time.now.iso8601(3),
+          severity: SEVERITY_TEXT[severity] || "UNKNOWN",
+          body: message.to_s.gsub(/\e\[[0-9;]*m/, ""),
+          controller: Thread.current[:lens_controller],
+          action: Thread.current[:lens_action],
+          request_id: Thread.current[:lens_request_id]
+        }.compact
+
+        dropped_now = 0
+        @mutex.synchronize do
+          if @buffer.size >= @max_buffer
+            @buffer.shift
+            @dropped += 1
+            dropped_now = @dropped
+          end
+          @buffer << record
+        end
+
+        maybe_warn_dropped(dropped_now) if dropped_now.positive?
+        true
+      end
+
+      def flush
+        records = @mutex.synchronize { @buffer.tap { @buffer = [] } }
+        return if records.empty?
+
+        body = JSON.generate(logs: records, service: @service_name, version: Lens::Rails::VERSION)
+
+        req = Net::HTTP::Post.new(@uri)
+        req["Content-Type"] = "application/octet-stream"
+        req["Authorization"] = "Bearer #{@token}"
+        req.body = Zlib.gzip(body)
+
+        Thread.current[:lens_in_export] = true
+        begin
+          Net::HTTP.start(@uri.host, @uri.port,
+            use_ssl: @uri.scheme == "https",
+            open_timeout: @open_timeout,
+            read_timeout: @read_timeout) { |http| http.request(req) }
+        ensure
+          Thread.current[:lens_in_export] = false
+        end
+      end
+
+      def shutdown(timeout:)
+        Thread.new { flush }.join(timeout)
+      rescue
+      end
+
+      def restart_flush_thread
+        BackoffLoop.new(base: 5, max: 60, name: "lens-log-flush").start { flush }
+      end
+
+      private
+
+      def maybe_warn_dropped(total_dropped)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        should_warn = @mutex.synchronize do
+          if now - @last_drop_warn_at >= DROP_WARN_INTERVAL
+            @last_drop_warn_at = now
+            true
+          else
+            false
+          end
+        end
+        Kernel.warn "Lens log buffer full: #{total_dropped} records dropped" if should_warn
+      end
+    end
+  end
+end

data/lib/lens/rails/metrics_exporter.rb

@@ -0,0 +1,153 @@
+require "net/http"
+require "json"
+require "zlib"
+require "lens/rails/backoff_loop"
+
+module Lens
+  module Rails
+    # Rack middleware that tracks request counts and durations,
+    # flushing them to Lens every 30 s via POST /v1/metrics.
+    class MetricsExporter
+      RESERVOIR_SIZE = 1024
+
+      def initialize(app, url:, token:, service_name:,
+        open_timeout: 2,
+        read_timeout: 2)
+        @app = app
+        @token = token
+        @service_name = service_name
+        @uri = URI("#{url}/v1/metrics")
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @mutex = Mutex.new
+        reset_window
+        restart_flush_thread
+        Lens::Rails.register_flushable(self)
+      end
+
+      def call(env)
+        Thread.current[:lens_request_id] = env["action_dispatch.request_id"]
+        wall_start = Time.now
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        status, headers, body = @app.call(env)
+        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
+        queue_time = parse_queue_time(env, wall_start)
+
+        @mutex.synchronize do
+          @request_count += 1
+          @error_count += 1 if status >= 500
+          @duration_sum += duration
+          @duration_min = duration if @duration_min.nil? || duration < @duration_min
+          @duration_max = duration if @duration_max.nil? || duration > @duration_max
+          if @samples.size < RESERVOIR_SIZE
+            @samples << duration
+          else
+            idx = rand(@request_count)
+            @samples[idx] = duration if idx < RESERVOIR_SIZE
+          end
+          if queue_time
+            @queue_samples << queue_time
+            @queue_sum += queue_time
+          end
+        end
+
+        [status, headers, body]
+      ensure
+        Thread.current[:lens_request_id] = nil
+      end
+
+      def flush
+        snapshot = @mutex.synchronize do
+          s = {count: @request_count, errors: @error_count,
+               sum: @duration_sum, min: @duration_min, max: @duration_max,
+               samples: @samples, queue_samples: @queue_samples, queue_sum: @queue_sum}
+          reset_window
+          s
+        end
+
+        return if snapshot[:count].zero?
+
+        now = Time.now.iso8601(3)
+        avg = snapshot[:sum] / snapshot[:count]
+        p50 = percentile(snapshot[:samples], 0.50)
+        p95 = percentile(snapshot[:samples], 0.95)
+
+        metrics = [
+          {name: "http.server.request_count", unit: "1", value: snapshot[:count].to_f, timestamp: now},
+          {name: "http.server.error_count", unit: "1", value: snapshot[:errors].to_f, timestamp: now},
+          {name: "http.server.duration", unit: "ms", value: avg, timestamp: now},
+          {name: "http.server.duration.p50", unit: "ms", value: p50, timestamp: now},
+          {name: "http.server.duration.p95", unit: "ms", value: p95, timestamp: now}
+        ]
+
+        if snapshot[:queue_samples].any?
+          q_avg = snapshot[:queue_sum] / snapshot[:queue_samples].size
+          q_p50 = percentile(snapshot[:queue_samples], 0.50)
+          q_p95 = percentile(snapshot[:queue_samples], 0.95)
+          metrics += [
+            {name: "http.server.queue_time", unit: "ms", value: q_avg, timestamp: now},
+            {name: "http.server.queue_time.p50", unit: "ms", value: q_p50, timestamp: now},
+            {name: "http.server.queue_time.p95", unit: "ms", value: q_p95, timestamp: now}
+          ]
+        end
+
+        body = JSON.generate(metrics: metrics, service: @service_name, version: Lens::Rails::VERSION)
+
+        req = Net::HTTP::Post.new(@uri)
+        req["Content-Type"] = "application/octet-stream"
+        req["Authorization"] = "Bearer #{@token}"
+        req.body = Zlib.gzip(body)
+
+        Thread.current[:lens_in_export] = true
+        begin
+          Net::HTTP.start(@uri.host, @uri.port,
+            use_ssl: @uri.scheme == "https",
+            open_timeout: @open_timeout,
+            read_timeout: @read_timeout) { |http| http.request(req) }
+        ensure
+          Thread.current[:lens_in_export] = false
+        end
+      end
+
+      def shutdown(timeout:)
+        Thread.new { flush }.join(timeout)
+      rescue
+      end
+
+      def restart_flush_thread
+        BackoffLoop.new(base: 30, max: 120, name: "lens-metrics-flush").start { flush }
+      end
+
+      private
+
+      def reset_window
+        @request_count = 0
+        @error_count = 0
+        @duration_sum = 0.0
+        @duration_min = nil
+        @duration_max = nil
+        @samples = []
+        @queue_samples = []
+        @queue_sum = 0.0
+      end
+
+      def parse_queue_time(env, wall_start)
+        raw = env["HTTP_X_REQUEST_START"]
+        return nil unless raw
+        val = raw.delete_prefix("t=").to_f
+        return nil if val.zero?
+        proxy_time = (val > 1e12) ? Time.at(val / 1000.0) : Time.at(val)
+        [(wall_start - proxy_time) * 1000.0, 0.0].max.round(2)
+      rescue
+        nil
+      end
+
+      def percentile(samples, p)
+        return 0.0 if samples.empty?
+        sorted = samples.sort
+        idx = (p * (sorted.size - 1)).round
+        sorted[idx]
+      end
+    end
+  end
+end

data/lib/lens/rails/railtie.rb

@@ -0,0 +1,82 @@
+require "lens/rails/log_exporter"
+require "lens/rails/metrics_exporter"
+require "lens/rails/requests_exporter"
+
+module Lens
+  module Rails
+    class Railtie < ::Rails::Railtie
+      # Broadcast Rails.logger to Lens.
+      initializer "lens.configure_logging", after: :load_config_initializers do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured?
+
+        ::Rails.logger.broadcast_to(
+          Lens::Rails::LogExporter.new(
+            url: cfg.url,
+            token: cfg.app_token,
+            service_name: cfg.service_name,
+            max_buffer: cfg.max_log_buffer,
+            min_severity: cfg.min_log_severity,
+            open_timeout: cfg.exporter_open_timeout,
+            read_timeout: cfg.exporter_read_timeout
+          )
+        )
+      end
+
+      # Rack middleware for request metrics.
+      initializer "lens.configure_metrics", after: :load_config_initializers do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured?
+
+        ::Rails.application.middleware.use(
+          Lens::Rails::MetricsExporter,
+          url: cfg.url,
+          token: cfg.app_token,
+          service_name: cfg.service_name,
+          open_timeout: cfg.exporter_open_timeout,
+          read_timeout: cfg.exporter_read_timeout
+        )
+      end
+
+      # Rack middleware + AS notification subscriptions for request/job traces.
+      initializer "lens.configure_requests", after: :load_config_initializers do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured?
+
+        ::Rails.application.middleware.use(Lens::Rails::RequestScopeMiddleware)
+
+        ActiveSupport.on_load(:active_job) do
+          include Lens::Rails::JobTracking
+        end
+
+        Lens::Rails::RequestsExporter.new(
+          url: cfg.url,
+          token: cfg.app_token,
+          service_name: cfg.service_name,
+          sql_threshold_ms: cfg.sql_threshold_ms,
+          sql_ignore: cfg.sql_ignore,
+          open_timeout: cfg.exporter_open_timeout,
+          read_timeout: cfg.exporter_read_timeout
+        )
+      end
+
+      # Flush pending data on clean shutdown, bounded by shutdown_timeout.
+      initializer "lens.at_exit", after: :load_config_initializers do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured?
+
+        at_exit { Lens::Rails.shutdown_flushables(timeout: cfg.shutdown_timeout) }
+      end
+
+      # Restart background flush threads after a Puma/Unicorn fork.
+      initializer "lens.after_fork" do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured? && ::Rails.application.config.respond_to?(:after_fork)
+
+        ::Rails.application.config.after_fork do
+          Lens::Rails.restart_flush_threads
+        end
+      end
+    end
+  end
+end

data/lib/lens/rails/requests_exporter.rb

@@ -0,0 +1,253 @@
+require "net/http"
+require "json"
+require "zlib"
+require "lens/rails/backoff_loop"
+
+module Lens
+  module Rails
+    # Tiny Rack middleware that opens a per-request operation accumulator so SQL
+    # and view notifications can attach to the right request on the current thread.
+    class RequestScopeMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        wall_start = Time.now
+        Thread.current[:lens_request_ops] = []
+        Thread.current[:lens_request_start] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Thread.current[:lens_request_wall_start] = wall_start
+        Thread.current[:lens_queue_time_ms] = parse_queue_time(env, wall_start)
+        @app.call(env)
+      ensure
+        Thread.current[:lens_request_ops] = nil
+        Thread.current[:lens_request_start] = nil
+        Thread.current[:lens_request_wall_start] = nil
+        Thread.current[:lens_queue_time_ms] = nil
+        Thread.current[:lens_controller] = nil
+        Thread.current[:lens_action] = nil
+      end
+
+      private
+
+      # Parses X-Request-Start set by kamal-proxy and nginx.
+      # Formats: "t=1234567890.123456" (seconds) or "1234567890123" (milliseconds).
+      def parse_queue_time(env, wall_start)
+        raw = env["HTTP_X_REQUEST_START"]
+        return nil unless raw
+        val = raw.delete_prefix("t=").to_f
+        return nil if val.zero?
+        proxy_time = (val > 1e12) ? Time.at(val / 1000.0) : Time.at(val)
+        [(wall_start - proxy_time) * 1000.0, 0.0].max.round(2)
+      rescue
+        nil
+      end
+    end
+
+    # ActiveJob concern injected via on_load(:active_job) in the Railtie.
+    # Opens a per-job operation accumulator around every perform call.
+    module JobTracking
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform do |_job, block|
+          Thread.current[:lens_job_ops] = []
+          Thread.current[:lens_job_start] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          Thread.current[:lens_job_wall_start] = Time.now
+          block.call
+        ensure
+          Thread.current[:lens_job_ops] = nil
+          Thread.current[:lens_job_start] = nil
+          Thread.current[:lens_job_wall_start] = nil
+        end
+      end
+    end
+
+    # Subscribes to ActionController, ActionView, ActiveRecord, and ActiveJob
+    # notifications and flushes collected records to POST /v1/requests.
+    class RequestsExporter
+      SKIP_SCHEMA = /\A(SCHEMA|ActiveRecord::SchemaMigration|ActiveRecord::InternalMetadata)\z/
+      SKIP_JOB_CLASS = /\ASolidQueue::/
+
+      def initialize(url:, token:, service_name:,
+        sql_threshold_ms: 0.0, sql_ignore: [],
+        open_timeout: 2, read_timeout: 2)
+        @uri = URI("#{url}/v1/requests")
+        @token = token
+        @service_name = service_name
+        @sql_threshold_ms = sql_threshold_ms
+        @sql_ignore = sql_ignore
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @mutex = Mutex.new
+        @requests = []
+        @jobs = []
+        subscribe!
+        restart_flush_thread
+        Lens::Rails.register_flushable(self)
+      end
+
+      def flush
+        requests, jobs = @mutex.synchronize do
+          [@requests.tap { @requests = [] }, @jobs.tap { @jobs = [] }]
+        end
+        return if requests.empty? && jobs.empty?
+
+        body = JSON.generate(requests: requests, jobs: jobs,
+          service: @service_name, version: Lens::Rails::VERSION)
+
+        req = Net::HTTP::Post.new(@uri)
+        req["Content-Type"] = "application/octet-stream"
+        req["Authorization"] = "Bearer #{@token}"
+        req.body = Zlib.gzip(body)
+
+        Thread.current[:lens_in_export] = true
+        begin
+          Net::HTTP.start(@uri.host, @uri.port,
+            use_ssl: @uri.scheme == "https",
+            open_timeout: @open_timeout,
+            read_timeout: @read_timeout) { |http| http.request(req) }
+        ensure
+          Thread.current[:lens_in_export] = false
+        end
+      end
+
+      def shutdown(timeout:)
+        Thread.new { flush }.join(timeout)
+      rescue
+      end
+
+      def restart_flush_thread
+        BackoffLoop.new(base: 30, max: 120, name: "lens-requests-flush").start { flush }
+      end
+
+      private
+
+      def subscribe!
+        # Tag current thread with controller/action for the log exporter to pick up.
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |event|
+          next if Thread.current[:lens_in_export]
+          Thread.current[:lens_controller] = event.payload[:controller]
+          Thread.current[:lens_action] = event.payload[:action]
+        end
+
+        # Accumulate SQL operations onto the current request or job.
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+          next if Thread.current[:lens_in_export]
+          record_sql(event)
+        end
+
+        # Accumulate view renders onto the current request.
+        ActiveSupport::Notifications.subscribe("render_template.action_view") do |event|
+          next if Thread.current[:lens_in_export]
+          record_view(event)
+        end
+
+        # Finalize an HTTP request record.
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |event|
+          next if Thread.current[:lens_in_export]
+          record_request(event)
+        end
+
+        # Finalize a background job record.
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |event|
+          next if Thread.current[:lens_in_export]
+          record_job(event)
+        end
+      end
+
+      def record_sql(event)
+        ops = Thread.current[:lens_request_ops] || Thread.current[:lens_job_ops]
+        t0 = Thread.current[:lens_request_start] || Thread.current[:lens_job_start]
+        return unless ops && t0
+
+        name = event.payload[:name].to_s
+        return if SKIP_SCHEMA.match?(name)
+
+        duration = event.duration.round(2)
+        return if duration < @sql_threshold_ms
+
+        sql = event.payload[:sql].to_s
+        return if @sql_ignore.any? { |re| sql.match?(re) }
+
+        offset = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000 - duration).round(2).clamp(0.0, Float::INFINITY)
+        ops << {"type" => "sql", "name" => name, "duration_ms" => duration, "offset_ms" => offset, "sql" => sql}
+      end
+
+      def record_view(event)
+        ops = Thread.current[:lens_request_ops]
+        t0 = Thread.current[:lens_request_start]
+        return unless ops && t0
+
+        name = event.payload[:identifier].to_s.sub(%r{.*/app/views/}, "")
+        duration = event.duration.round(2)
+        offset = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000 - duration).round(2).clamp(0.0, Float::INFINITY)
+        ops << {"type" => "view", "name" => name, "duration_ms" => duration, "offset_ms" => offset}
+      end
+
+      def record_request(event)
+        ops = Thread.current[:lens_request_ops] || []
+        Thread.current[:lens_request_ops] = nil
+
+        payload = event.payload
+        sql_ops = ops.select { |op| op["type"] == "sql" }
+        view_ops = ops.select { |op| op["type"] == "view" }
+
+        rec = {
+          "id" => Thread.current[:lens_request_id],
+          "controller" => payload[:controller],
+          "action" => payload[:action],
+          "method" => payload[:method],
+          "path" => payload[:path],
+          "status" => payload[:status],
+          "duration_ms" => event.duration.round(2),
+          "sql_count" => sql_ops.size,
+          "sql_duration_ms" => sql_ops.sum { |op| op["duration_ms"] }.round(2),
+          "view_duration_ms" => view_ops.sum { |op| op["duration_ms"] }.round(2),
+          "queue_time_ms" => Thread.current[:lens_queue_time_ms],
+          "started_at" => (Thread.current[:lens_request_wall_start] || Time.now).iso8601(3),
+          "error" => build_error(payload[:exception], payload[:exception_object]),
+          "operations" => ops
+        }.compact
+
+        @mutex.synchronize { @requests << rec }
+      end
+
+      def record_job(event)
+        ops = Thread.current[:lens_job_ops] || []
+        Thread.current[:lens_job_ops] = nil
+
+        payload = event.payload
+        job = payload[:job]
+        return if job.class.name&.match?(SKIP_JOB_CLASS)
+
+        wall_start = Thread.current[:lens_job_wall_start] || Time.now
+        sql_ops = ops.select { |op| op["type"] == "sql" }
+        enqueued = job.respond_to?(:enqueued_at) && job.enqueued_at
+        latency_ms = enqueued ? ((wall_start - enqueued) * 1000).round(2) : nil
+
+        rec = {
+          "id" => job.job_id,
+          "job_class" => job.class.name,
+          "queue" => job.queue_name,
+          "duration_ms" => event.duration.round(2),
+          "latency_ms" => latency_ms,
+          "sql_count" => sql_ops.size,
+          "sql_duration_ms" => sql_ops.sum { |op| op["duration_ms"] }.round(2),
+          "started_at" => wall_start.iso8601(3),
+          "error" => build_error(payload[:exception], payload[:exception_object]),
+          "operations" => ops
+        }.compact
+
+        @mutex.synchronize { @jobs << rec }
+      end
+
+      def build_error(exception, exception_object)
+        return nil unless exception
+        klass, message = exception
+        backtrace = exception_object&.backtrace&.first(20) || []
+        {"class" => klass, "message" => message, "backtrace" => backtrace}
+      end
+    end
+  end
+end

data/lib/lens/rails/version.rb

@@ -0,0 +1,5 @@
+module Lens
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/lens/rails.rb

@@ -0,0 +1,36 @@
+require "lens/rails/version"
+require "lens/rails/configuration"
+
+module Lens
+  module Rails
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def register_flushable(exporter)
+        flushables << exporter
+      end
+
+      def restart_flush_threads
+        flushables.each(&:restart_flush_thread)
+      end
+
+      def shutdown_flushables(timeout:)
+        flushables.each { |f| f.shutdown(timeout: timeout) }
+      end
+
+      private
+
+      def flushables
+        @flushables ||= []
+      end
+    end
+  end
+end
+
+require "lens/rails/railtie" if defined?(::Rails::Railtie)

data/lib/lens-rails.rb

@@ -0,0 +1 @@
+require "lens/rails"

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: lens-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Axel Gustav
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Drop-in Rails gem that collects logs, metrics, and request traces via
+  ActiveSupport::Notifications and ships them to a Lens instance. Uses gzip-compressed
+  JSON — no protobuf, no OpenTelemetry SDK required.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/lens-rails.rb
+- lib/lens/rails.rb
+- lib/lens/rails/backoff_loop.rb
+- lib/lens/rails/configuration.rb
+- lib/lens/rails/log_exporter.rb
+- lib/lens/rails/metrics_exporter.rb
+- lib/lens/rails/railtie.rb
+- lib/lens/rails/requests_exporter.rb
+- lib/lens/rails/version.rb
+homepage: https://codefloe.com/GusTech/lens-rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Zero-config APM integration for Lens
+test_files: []