lens-rails 0.1.0 → 0.1.1

checksums.yaml

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

data/README.md

@@ -1,6 +1,6 @@
 # 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.
+Zero-config APM integration for [Lens](https://github.com/gustech/lens). Drop this gem into any Rails app and logs, metrics, requests, jobs, and errors start flowing to your Lens instance automatically — no OpenTelemetry SDK, no protobuf, no additional processes.
 
 ## Installation
 
@@ -27,9 +27,12 @@ That's it. No initializer required.
 | **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 |
+| **Errors** | `Rails.error` | All reported exceptions — class, message, backtrace, context, severity |
 
 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.
 
+Errors are deduplicated server-side by fingerprint (app + class + message) and surfaced with a resolve workflow.
+
 ## Configuration
 
 To override defaults, add an initializer:
@@ -64,9 +67,29 @@ Lens::Rails.configure do |config|
 
   # Maximum time to wait for a final flush on process shutdown (seconds). Default: 5.
   config.shutdown_timeout = 5
+
+  # Exception classes to suppress from error reporting.
+  # Defaults to common Rails routing and auth errors (RoutingError, RecordNotFound, etc.).
+  config.error_ignore_classes = %w[
+    ActionController::RoutingError
+    ActiveRecord::RecordNotFound
+  ]
+
+  # Queue size for error records (drop-on-full). Default: 1_000.
+  config.max_error_buffer = 1_000
 end
 ```
 
+## Reporting errors explicitly
+
+The gem subscribes to `Rails.error` automatically, so any exception reported through that interface (including unhandled exceptions in requests and jobs) is captured. To report an error directly:
+
+```ruby
+Lens.error(exception, context: { user_id: current_user.id })
+```
+
+This delegates to `Rails.error.report` with `handled: true`, so the exception is not re-raised.
+
 ## How it works
 
 The gem wires up three components via a Railtie:
@@ -74,6 +97,7 @@ 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.
+- **`ErrorExporter`** — registers as a `Rails.error` subscriber and ships error records to `POST /v1/errors`. Context hashes are sanitized (circular refs, depth limits, 64 KB string cap) before serialization.
 
 All payloads are gzip-compressed JSON. Background flush threads restart automatically after a Puma or Unicorn fork.
 

data/lib/lens/rails/configuration.rb

@@ -5,7 +5,8 @@ module Lens
         :max_log_buffer, :min_log_severity,
         :sql_threshold_ms, :sql_ignore,
         :exporter_open_timeout, :exporter_read_timeout,
-        :shutdown_timeout
+        :shutdown_timeout,
+        :error_ignore_classes, :max_error_buffer
 
       def initialize
         @url = ENV["LENS_URL"]
@@ -18,6 +19,20 @@ module Lens
         @exporter_open_timeout = 2
         @exporter_read_timeout = 2
         @shutdown_timeout = 5
+        @error_ignore_classes = %w[
+          ActionController::RoutingError
+          AbstractController::ActionNotFound
+          ActionController::MethodNotAllowed
+          ActionController::UnknownHttpMethod
+          ActionController::UnknownFormat
+          ActionController::InvalidAuthenticityToken
+          ActionController::InvalidCrossOriginRequest
+          ActionDispatch::Http::Parameters::ParseError
+          ActionController::BadRequest
+          ActionController::ParameterMissing
+          ActiveRecord::RecordNotFound
+        ]
+        @max_error_buffer = 1_000
       end
 
       def configured?

data/lib/lens/rails/error_exporter.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "zlib"
+require "lens/rails/sanitizer"
+
+module Lens
+  module Rails
+    # Implements the Rails.error subscriber interface. Buffers error reports on
+    # a SizedQueue and ships them in batches to POST /v1/errors via a persistent
+    # HTTP connection on a dedicated worker thread.
+    class ErrorExporter
+      BATCH_SIZE = 200
+
+      def initialize(url:, token:, service_name:,
+                     ignore_classes: [],
+                     max_buffer: 1_000,
+                     open_timeout: 2, read_timeout: 2)
+        @uri = URI("#{url}/v1/errors")
+        @token = token
+        @service_name = service_name
+        @ignore_classes = ignore_classes
+        @max_buffer = max_buffer
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @queue = SizedQueue.new(max_buffer)
+        @http = nil
+        @fork_mutex = Mutex.new
+        start_worker
+        Lens::Rails.register_flushable(self)
+      end
+
+      # Rails.error subscriber interface.
+      def report(error, handled:, severity: :error, context: {}, source: nil)
+        return if @ignore_classes.include?(error.class.name)
+
+        rec = {
+          "class" => error.class.name,
+          "message" => error.message.to_s.first(2_000),
+          "backtrace" => error.backtrace&.first(50) || [],
+          "context" => Sanitizer.sanitize(context || {}),
+          "severity" => severity.to_s,
+          "source" => source,
+          "occurred_at" => Time.now.iso8601(3),
+        }.compact
+
+        ensure_worker!
+        @queue.push(rec, true)
+      rescue ThreadError
+        # Buffer full — drop silently
+      end
+
+      def shutdown(timeout:)
+        @queue.close
+        @worker&.join(timeout)
+      rescue
+      end
+
+      def ensure_worker!
+        return if @worker&.alive?
+        @fork_mutex.synchronize do
+          return if @worker&.alive?
+          restart_flush_thread
+        end
+      end
+
+      def restart_flush_thread
+        begin
+          @worker&.kill
+        rescue
+          nil
+        end
+        close_http
+        @queue = SizedQueue.new(@max_buffer)
+        start_worker
+      end
+
+      private
+
+      def start_worker
+        @worker = Thread.new do
+          Thread.current.name = "lens-errors-worker"
+          Thread.current.report_on_exception = true
+          run_worker
+        end
+      end
+
+      def run_worker
+        loop do
+          batch = collect_batch
+          send_batch(batch)
+        end
+      rescue ClosedQueueError
+        # Normal shutdown
+      end
+
+      def collect_batch
+        item = @queue.pop
+        raise ClosedQueueError if item.nil?
+        batch = [item]
+        loop do
+          break if batch.size >= BATCH_SIZE
+          batch << @queue.pop(true)
+        rescue ThreadError, ClosedQueueError
+          break
+        end
+        batch
+      end
+
+      def send_batch(items)
+        return if items.empty?
+
+        body = JSON.generate(errors: items, 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
+          post_with_retry(req)
+        ensure
+          Thread.current[:lens_in_export] = false
+        end
+      rescue => e
+        warn "lens-errors-worker: #{e.class}: #{e.message}"
+        close_http
+      end
+
+      def post_with_retry(req)
+        http.request(req)
+      rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED
+        close_http
+        http.request(req)
+      end
+
+      def http
+        return @http if @http&.active?
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = @uri.scheme == "https"
+        @http.open_timeout = @open_timeout
+        @http.read_timeout = @read_timeout
+        @http.keep_alive_timeout = 30
+        @http.start
+      end
+
+      def close_http
+        begin
+          @http&.finish
+        rescue
+          nil
+        end
+        @http = nil
+      end
+    end
+  end
+end

data/lib/lens/rails/log_exporter.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 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.
+    # Logger sink that buffers log records in a thread-safe Queue and ships
+    # them to POST /v1/logs via a single persistent HTTPS connection.
+    # A dedicated worker thread blocks on the queue and drains in batches,
+    # so there are no timer wakeups that can interfere with Puma response writes.
     class LogExporter < ::Logger
       SEVERITY_TEXT = {
         ::Logger::DEBUG => "DEBUG",
@@ -17,7 +20,7 @@ module Lens
         ::Logger::UNKNOWN => "UNKNOWN"
       }.freeze
 
-      DROP_WARN_INTERVAL = 60.0
+      BATCH_SIZE = 500
 
       def initialize(url:, token:, service_name:,
         max_buffer: 10_000,
@@ -28,15 +31,13 @@ module Lens
         @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
+        @max_buffer = max_buffer
+        @queue = SizedQueue.new(max_buffer)
+        @http = nil
+        start_worker
         Lens::Rails.register_flushable(self)
       end
 
@@ -55,29 +56,68 @@ module Lens
           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]
+          request_id: Thread.current[:lens_request_id],
+          job_id: Thread.current[:lens_job_id]
         }.compact
 
-        dropped_now = 0
-        @mutex.synchronize do
-          if @buffer.size >= @max_buffer
-            @buffer.shift
-            @dropped += 1
-            dropped_now = @dropped
-          end
-          @buffer << record
+        @queue.push(record, true)
+      rescue ThreadError
+        # Buffer full, drop record silently
+      end
+
+      def shutdown(timeout:)
+        @queue.close
+        @worker&.join(timeout)
+      rescue
+      end
+
+      def restart_flush_thread
+        begin
+          @worker&.kill
+        rescue
+          nil
+        end
+        close_http
+        @queue = SizedQueue.new(@max_buffer)
+        start_worker
+      end
+
+      private
+
+      def start_worker
+        @worker = Thread.new do
+          Thread.current.name = "lens-log-worker"
+          Thread.current.report_on_exception = true
+          run_worker
         end
+      end
 
-        maybe_warn_dropped(dropped_now) if dropped_now.positive?
-        true
+      def run_worker
+        loop do
+          batch = collect_batch
+          send_batch(batch)
+        end
+      rescue ClosedQueueError
+        # Queue empty and closed — normal shutdown
+      end
+
+      def collect_batch
+        item = @queue.pop
+        raise ClosedQueueError if item.nil?
+        batch = [item]
+        loop do
+          break if batch.size >= BATCH_SIZE
+          batch << @queue.pop(true)
+        rescue ThreadError, ClosedQueueError
+          break
+        end
+        batch
       end
 
-      def flush
-        records = @mutex.synchronize { @buffer.tap { @buffer = [] } }
+      def send_batch(records)
         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}"
@@ -85,37 +125,39 @@ module Lens
 
         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) }
+          post_with_retry(req)
         ensure
           Thread.current[:lens_in_export] = false
         end
+      rescue => e
+        warn "lens-log-worker: #{e.class}: #{e.message}"
+        close_http
       end
 
-      def shutdown(timeout:)
-        Thread.new { flush }.join(timeout)
-      rescue
+      def post_with_retry(req)
+        http.request(req)
+      rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED
+        close_http
+        http.request(req)
       end
 
-      def restart_flush_thread
-        BackoffLoop.new(base: 5, max: 60, name: "lens-log-flush").start { flush }
+      def http
+        return @http if @http&.active?
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = @uri.scheme == "https"
+        @http.open_timeout = @open_timeout
+        @http.read_timeout = @read_timeout
+        @http.keep_alive_timeout = 30
+        @http.start
       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
+      def close_http
+        begin
+          @http&.finish
+        rescue
+          nil
         end
-        Kernel.warn "Lens log buffer full: #{total_dropped} records dropped" if should_warn
+        @http = nil
       end
     end
   end

data/lib/lens/rails/metrics_exporter.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 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.
+    # Rack middleware that tracks request counts and durations, flushing
+    # aggregated metrics to POST /v1/metrics every 30s via a persistent
+    # HTTPS connection.
     class MetricsExporter
       RESERVOIR_SIZE = 1024
+      FLUSH_INTERVAL = 30
 
       def initialize(app, url:, token:, service_name:,
         open_timeout: 2,
@@ -20,8 +23,9 @@ module Lens
         @open_timeout = open_timeout
         @read_timeout = read_timeout
         @mutex = Mutex.new
+        @http = nil
         reset_window
-        restart_flush_thread
+        start_flush_thread
         Lens::Rails.register_flushable(self)
       end
 
@@ -56,11 +60,42 @@ module Lens
         Thread.current[:lens_request_id] = nil
       end
 
+      def shutdown(timeout:)
+        @flush_thread&.kill
+        Thread.new { flush }.join(timeout)
+      rescue
+      end
+
+      def restart_flush_thread
+        begin
+          @flush_thread&.kill
+        rescue
+          nil
+        end
+        close_http
+        start_flush_thread
+      end
+
+      private
+
+      def start_flush_thread
+        @flush_thread = Thread.new do
+          Thread.current.name = "lens-metrics-flush"
+          Thread.current.report_on_exception = true
+          loop do
+            sleep FLUSH_INTERVAL
+            flush
+          end
+        end
+      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}
+          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
@@ -92,7 +127,6 @@ module Lens
         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}"
@@ -100,25 +134,40 @@ module Lens
 
         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) }
+          post_with_retry(req)
         ensure
           Thread.current[:lens_in_export] = false
         end
+      rescue => e
+        warn "lens-metrics-flush: #{e.class}: #{e.message}"
+        close_http
       end
 
-      def shutdown(timeout:)
-        Thread.new { flush }.join(timeout)
-      rescue
+      def post_with_retry(req)
+        http.request(req)
+      rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED
+        close_http
+        http.request(req)
       end
 
-      def restart_flush_thread
-        BackoffLoop.new(base: 30, max: 120, name: "lens-metrics-flush").start { flush }
+      def http
+        return @http if @http&.active?
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = @uri.scheme == "https"
+        @http.open_timeout = @open_timeout
+        @http.read_timeout = @read_timeout
+        @http.keep_alive_timeout = 30
+        @http.start
       end
 
-      private
+      def close_http
+        begin
+          @http&.finish
+        rescue
+          nil
+        end
+        @http = nil
+      end
 
       def reset_window
         @request_count = 0

data/lib/lens/rails/railtie.rb

@@ -1,6 +1,7 @@
 require "lens/rails/log_exporter"
 require "lens/rails/metrics_exporter"
 require "lens/rails/requests_exporter"
+require "lens/rails/error_exporter"
 
 module Lens
   module Rails
@@ -10,17 +11,21 @@ module Lens
         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
-          )
+        log_exporter = 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,
         )
+
+        if ::Rails.logger.respond_to?(:broadcast_to)
+          ::Rails.logger.broadcast_to(log_exporter)
+        else
+          ::Rails.logger = ActiveSupport::BroadcastLogger.new(::Rails.logger, log_exporter)
+        end
       end
 
       # Rack middleware for request metrics.
@@ -34,7 +39,7 @@ module Lens
           token: cfg.app_token,
           service_name: cfg.service_name,
           open_timeout: cfg.exporter_open_timeout,
-          read_timeout: cfg.exporter_read_timeout
+          read_timeout: cfg.exporter_read_timeout,
         )
       end
 
@@ -56,10 +61,28 @@ module Lens
           sql_threshold_ms: cfg.sql_threshold_ms,
           sql_ignore: cfg.sql_ignore,
           open_timeout: cfg.exporter_open_timeout,
-          read_timeout: cfg.exporter_read_timeout
+          read_timeout: cfg.exporter_read_timeout,
         )
       end
 
+      # Subscribe to Rails.error to capture all reported exceptions.
+      initializer "lens.configure_errors", after: :load_config_initializers do
+        cfg = Lens::Rails.configuration
+        next unless cfg.configured?
+
+        exporter = Lens::Rails::ErrorExporter.new(
+          url: cfg.url,
+          token: cfg.app_token,
+          service_name: cfg.service_name,
+          ignore_classes: cfg.error_ignore_classes,
+          max_buffer: cfg.max_error_buffer,
+          open_timeout: cfg.exporter_open_timeout,
+          read_timeout: cfg.exporter_read_timeout,
+        )
+
+        ::Rails.error.subscribe(exporter)
+      end
+
       # Flush pending data on clean shutdown, bounded by shutdown_timeout.
       initializer "lens.at_exit", after: :load_config_initializers do
         cfg = Lens::Rails.configuration

data/lib/lens/rails/requests_exporter.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require "net/http"
 require "json"
 require "zlib"
-require "lens/rails/backoff_loop"
 
 module Lens
   module Rails
@@ -14,12 +15,14 @@ module Lens
 
       def call(env)
         wall_start = Time.now
+        Thread.current[:lens_request_id] = env["action_dispatch.request_id"]
         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_id] = nil
         Thread.current[:lens_request_ops] = nil
         Thread.current[:lens_request_start] = nil
         Thread.current[:lens_request_wall_start] = nil
@@ -30,8 +33,6 @@ module Lens
 
       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
@@ -45,57 +46,138 @@ module Lens
     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|
+        before_enqueue { @lens_request_id = Thread.current[:lens_request_id] }
+
+        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
+          Thread.current[:lens_job_request_id] = job.lens_request_id
+          Thread.current[:lens_job_id] = job.job_id
           block.call
         ensure
           Thread.current[:lens_job_ops] = nil
           Thread.current[:lens_job_start] = nil
           Thread.current[:lens_job_wall_start] = nil
+          Thread.current[:lens_job_request_id] = nil
+          Thread.current[:lens_job_id] = nil
         end
       end
+
+      def lens_request_id
+        @lens_request_id
+      end
+
+      def serialize
+        super.merge("lens_request_id" => @lens_request_id)
+      end
+
+      def deserialize(job_data)
+        @lens_request_id = job_data.delete("lens_request_id")
+        super
+      end
     end
 
     # Subscribes to ActionController, ActionView, ActiveRecord, and ActiveJob
-    # notifications and flushes collected records to POST /v1/requests.
+    # notifications and pushes collected records onto a Queue. A dedicated worker
+    # thread drains the queue in batches and ships them to POST /v1/requests via
+    # a single persistent HTTPS connection.
     class RequestsExporter
       SKIP_SCHEMA = /\A(SCHEMA|ActiveRecord::SchemaMigration|ActiveRecord::InternalMetadata)\z/
       SKIP_JOB_CLASS = /\ASolidQueue::/
 
+      BATCH_SIZE = 200
+
       def initialize(url:, token:, service_name:,
         sql_threshold_ms: 0.0, sql_ignore: [],
+        max_buffer: 5_000,
         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
+        @max_buffer = max_buffer
         @open_timeout = open_timeout
         @read_timeout = read_timeout
-        @mutex = Mutex.new
-        @requests = []
-        @jobs = []
+        @queue = SizedQueue.new(max_buffer)
+        @http = nil
+        @fork_mutex = Mutex.new
         subscribe!
-        restart_flush_thread
+        start_worker
         Lens::Rails.register_flushable(self)
       end
 
-      def flush
-        requests, jobs = @mutex.synchronize do
-          [@requests.tap { @requests = [] }, @jobs.tap { @jobs = [] }]
+      def shutdown(timeout:)
+        @queue.close
+        @worker&.join(timeout)
+      rescue
+      end
+
+      def ensure_worker!
+        return if @worker&.alive?
+        @fork_mutex.synchronize do
+          return if @worker&.alive?
+          restart_flush_thread
         end
+      end
+
+      def restart_flush_thread
+        begin
+          @worker&.kill
+        rescue
+          nil
+        end
+        close_http
+        @queue = SizedQueue.new(@max_buffer)
+        start_worker
+      end
+
+      private
+
+      def start_worker
+        @worker = Thread.new do
+          Thread.current.name = "lens-requests-worker"
+          Thread.current.report_on_exception = true
+          run_worker
+        end
+      end
+
+      def run_worker
+        loop do
+          batch = collect_batch
+          send_batch(batch)
+        end
+      rescue ClosedQueueError
+        # Queue empty and closed — normal shutdown
+      end
+
+      def collect_batch
+        item = @queue.pop
+        raise ClosedQueueError if item.nil?
+        batch = [item]
+        loop do
+          break if batch.size >= BATCH_SIZE
+          batch << @queue.pop(true)
+        rescue ThreadError, ClosedQueueError
+          break
+        end
+        batch
+      end
+
+      def send_batch(items)
+        return if items.empty?
+
+        requests = items.filter_map { |i| i[:data] if i[:type] == :request }
+        jobs = items.filter_map { |i| i[:data] if i[:type] == :job }
         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}"
@@ -103,53 +185,63 @@ module Lens
 
         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) }
+          post_with_retry(req)
         ensure
           Thread.current[:lens_in_export] = false
         end
+      rescue => e
+        warn "lens-requests-worker: #{e.class}: #{e.message}"
+        close_http
       end
 
-      def shutdown(timeout:)
-        Thread.new { flush }.join(timeout)
-      rescue
+      def post_with_retry(req)
+        http.request(req)
+      rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNREFUSED
+        close_http
+        http.request(req)
       end
 
-      def restart_flush_thread
-        BackoffLoop.new(base: 30, max: 120, name: "lens-requests-flush").start { flush }
+      def http
+        return @http if @http&.active?
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = @uri.scheme == "https"
+        @http.open_timeout = @open_timeout
+        @http.read_timeout = @read_timeout
+        @http.keep_alive_timeout = 30
+        @http.start
       end
 
-      private
+      def close_http
+        begin
+          @http&.finish
+        rescue
+          nil
+        end
+        @http = nil
+      end
 
       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)
@@ -198,7 +290,7 @@ module Lens
           "controller" => payload[:controller],
           "action" => payload[:action],
           "method" => payload[:method],
-          "path" => payload[:path],
+          "path" => route_pattern(payload[:request], payload[:path].to_s),
           "status" => payload[:status],
           "duration_ms" => event.duration.round(2),
           "sql_count" => sql_ops.size,
@@ -210,7 +302,10 @@ module Lens
           "operations" => ops
         }.compact
 
-        @mutex.synchronize { @requests << rec }
+        ensure_worker!
+        @queue.push({type: :request, data: rec}, true)
+      rescue ThreadError
+        # Buffer full, drop record silently
       end
 
       def record_job(event)
@@ -228,6 +323,7 @@ module Lens
 
         rec = {
           "id" => job.job_id,
+          "request_id" => Thread.current[:lens_job_request_id],
           "job_class" => job.class.name,
           "queue" => job.queue_name,
           "duration_ms" => event.duration.round(2),
@@ -239,7 +335,10 @@ module Lens
           "operations" => ops
         }.compact
 
-        @mutex.synchronize { @jobs << rec }
+        ensure_worker!
+        @queue.push({type: :job, data: rec}, true)
+      rescue ThreadError
+        # Buffer full, drop record silently
       end
 
       def build_error(exception, exception_object)
@@ -248,6 +347,14 @@ module Lens
         backtrace = exception_object&.backtrace&.first(20) || []
         {"class" => klass, "message" => message, "backtrace" => backtrace}
       end
+
+      def route_pattern(request, raw_path)
+        if request.respond_to?(:route_uri_pattern)
+          request.route_uri_pattern&.chomp("(.:format)")
+        end || raw_path.split("?", 2).first
+      rescue
+        raw_path.split("?", 2).first
+      end
     end
   end
 end

data/lib/lens/rails/sanitizer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Adapted from solid_errors/sanitizer.rb (originally from honeybadger-ruby).
+# Handles circular refs, BasicObject, depth limits, huge strings, and
+# object_id stripping before serializing context hashes to JSON.
+
+module Lens
+  module Rails
+    class Sanitizer
+      BASIC_OBJECT = "#<BasicObject>".freeze
+      DEPTH = "[DEPTH]".freeze
+      RAISED = "[RAISED]".freeze
+      RECURSION = "[RECURSION]".freeze
+      TRUNCATED = "[TRUNCATED]".freeze
+      MAX_STRING = 65_536
+
+      def self.sanitize(data)
+        @instance ||= new
+        @instance.sanitize(data)
+      end
+
+      def initialize(max_depth: 20)
+        @max_depth = max_depth
+      end
+
+      def sanitize(data, depth = 0, stack = nil)
+        return BASIC_OBJECT if basic_object?(data)
+
+        if recursive?(data)
+          return RECURSION if stack&.include?(data.object_id)
+          stack = stack ? stack.dup : Set.new
+          stack << data.object_id
+        end
+
+        case data
+        when Hash
+          return DEPTH if depth >= @max_depth
+          data.each_with_object({}) do |(k, v), h|
+            h[k.is_a?(Symbol) ? k : sanitize(k, depth + 1, stack)] = sanitize(v, depth + 1, stack)
+          end
+        when Array, Set
+          return DEPTH if depth >= @max_depth
+          data.to_a.map { |v| sanitize(v, depth + 1, stack) }
+        when Numeric, TrueClass, FalseClass, NilClass
+          data
+        when String
+          sanitize_string(data)
+        else
+          klass = data.class
+          begin
+            str = String(data)
+          rescue
+            return RAISED
+          end
+          return "#<#{klass.name}>" if str.include?("#<") && str.include?(">")
+          sanitize_string(str)
+        end
+      end
+
+      private
+
+      def basic_object?(obj)
+        obj.respond_to?(:to_s)
+        false
+      rescue
+        true
+      end
+
+      def recursive?(data)
+        data.is_a?(Hash) || data.is_a?(Array) || data.is_a?(Set)
+      end
+
+      def sanitize_string(str)
+        str = str.gsub(/#<(.*?):0x.*?>/, '#<\1>')
+        return str if str.size <= MAX_STRING
+        str[0...MAX_STRING] + TRUNCATED
+      end
+    end
+  end
+end

data/lib/lens/rails/version.rb

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

data/lib/lens/rails.rb

@@ -24,6 +24,10 @@ module Lens
         flushables.each { |f| f.shutdown(timeout: timeout) }
       end
 
+      def error(exception, context: {}, severity: :error, handled: true)
+        ::Rails.error.report(exception, context: context, severity: severity, handled: handled)
+      end
+
       private
 
       def flushables

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lens-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Axel Gustav
@@ -21,10 +21,12 @@ files:
 - lib/lens/rails.rb
 - lib/lens/rails/backoff_loop.rb
 - lib/lens/rails/configuration.rb
+- lib/lens/rails/error_exporter.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/sanitizer.rb
 - lib/lens/rails/version.rb
 homepage: https://codefloe.com/GusTech/lens-rails
 licenses: