koderift-rails 1.3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e49d9d7f56f87dde732a6465a3ced955d8960b692408f6818cf686e30965c8c
+  data.tar.gz: 299cb7491b8211baa559aebbca51b7759929891caefe5048d562791431759202
+SHA512:
+  metadata.gz: e01be29d2c18193b54c04d93ae80ce6bca85d58b8c3c57e92227d5e706c4e033d8d13cb103c285a61d90a19e14431f80eec95e2ace8ed38fe2bbb8f92cd9fabf
+  data.tar.gz: b620b59cbe817e063ef7f862be7ed1fc0a36390b6465b4f52b20d59afe51f34de53a47dc72371f7ba14a0079c579a3946c16dbfa1bb3d7cd316c7ad381afe53f

data/CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+All notable changes to `koderift-rails` are documented here.
+
+This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+Releases before 1.3.4 were installed from git and were never published to
+RubyGems; they are listed for continuity.
+
+## [1.3.4] - 2026-08-27
+
+First release published to RubyGems.
+
+### Fixed
+- An external HTTP call could be recorded twice on a single request, inflating
+  the external-call count and the time attributed to it.
+
+### Changed
+- Packaging only: added a LICENSE file, gem metadata (source, changelog and
+  issue links, MFA required for publishing) and this changelog. No change to
+  what the gem captures or emits.
+
+## [1.3.3] - 2026-05-25
+### Added
+- The current Rails environment is emitted with each request, so traces can be
+  filtered by environment rather than inferring it from the host.
+
+## [1.3.2] - 2026-05-25
+### Changed
+- Improved internal logging.
+
+## [1.3.1] - 2026-05-25
+### Added
+- External HTTP calls made from Sidekiq jobs are tracked, not just those made
+  during a web request.
+
+## [1.3.0] - 2026-05-25
+### Changed
+- Removed the per-request limits on captured spans; the full set is emitted and
+  trimmed downstream by the ingest agent.
+
+## [1.2.2] - 2026-05-25
+### Fixed
+- Maintenance release.
+
+## [1.2.1] - 2026-05-24
+### Fixed
+- Searchkick instrumentation issue reported by a client.
+
+## [1.2.0] - 2026-05-24
+### Added
+- Search query instrumentation (`search.searchkick` and
+  `multi_search.searchkick`).
+
+## [1.0.6] - 2026-05-24
+### Added
+- RUM token support.
+
+## [1.0.5] - 2026-05-24
+### Added
+- Browser RUM instrumentation.
+
+## [1.0.4] - 2026-05-24
+### Added
+- Distributed tracing: a trace id is propagated across services via the
+  `X-Koderift-Trace-ID` header.
+
+## [1.0.3] - 2026-05-23
+### Added
+- External HTTP call tracking via a `Net::HTTP` patch.
+
+## [1.0.2] - 2026-05-22
+### Fixed
+- Maintenance release.
+
+## [1.0.1] - 2025-12-10
+### Fixed
+- Load-order issue when the gem initialised before Lograge.
+
+## [1.0.0] - 2025-08-11
+### Added
+- Initial release: request instrumentation, partial and SQL span capture,
+  breadcrumbs, and automatic Lograge configuration.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Koderift
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# koderift-rails
+
+Rails instrumentation gem for [Koderift](https://koderift.com) log analytics.
+
+Automatically captures request context, performance data, and error
+information — no manual `ApplicationController` changes needed.
+
+## Installation
+
+Requires Ruby >= 2.7 and Rails 7.1-8.x.
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'koderift-rails', '~> 1.3'
+```
+
+Run `bundle install`. Lograge is a dependency of this gem and is installed
+with it - you do not need to add it yourself.
+
+## Configuration
+
+Create `config/initializers/koderift.rb`:
+
+```ruby
+Koderift::Rails.configure do |config|
+  config.project_token = ENV['KODERIFT_PROJECT_TOKEN']
+
+  # Optional: customise how the current user is resolved
+  # config.current_user = ->(controller) { controller.current_user }
+end
+```
+
+Set `KODERIFT_PROJECT_TOKEN` in your environment to the token from your
+project's Log Analytics settings page in Koderift.
+
+## What it captures
+
+* Controller, action, path, method, status, duration
+* DB runtime, view runtime, allocations
+* Current user ID
+* Request ID, IP address, user agent, referer
+* Request params (filtered — passwords, tokens etc removed)
+* Top 5 slowest partials with render times
+* Top 5 slowest SQL queries
+* Last 20 breadcrumbs (ordered partial renders + SQL queries)
+* Exception class, message, and cause chain
+* Stack traces (requires `keep_original_rails_log: true`)
+
+## Requirements
+
+* Ruby >= 2.7
+* Rails >= 6.1
+* lograge >= 0.11

data/lib/koderift/rails/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Koderift
+  module Rails
+    class Configuration
+      # Required: identifies which project this app reports to.
+      # Set from an environment variable in the initializer.
+      attr_accessor :project_token
+
+      # Lambda called with the controller instance to get the current user.
+      # Default tries common patterns. Override if your app is different.
+      # Example: ->(controller) { controller.current_user }
+      attr_accessor :current_user
+
+      # Parameters to filter from captured request params.
+      attr_accessor :filter_params
+
+      # Maximum number of breadcrumbs to capture per request.
+      attr_accessor :max_breadcrumbs
+
+      # Hosts to exclude from external call tracking (e.g. internal services,
+      # localhost, known noise). Always excludes 127.0.0.1 and localhost.
+      attr_accessor :external_call_ignore_hosts
+
+      # Whether to enable the instrumentation. Set to false to disable
+      # without removing the gem.
+      attr_accessor :enabled
+
+      # Whether to enable Browser RUM. Set to false for API-only apps.
+      # Defaults to true — the meta tag is harmless if rum.js is not loaded.
+      attr_accessor :rum_enabled
+
+      # Fraction of sessions to capture (0.0–1.0). Default 0.1 (10%).
+      # Passed to rum.js so sampling happens client-side.
+      attr_accessor :rum_sampling_rate
+
+      # Threshold in milliseconds above which a Sidekiq job is marked 'slow'
+      # in the emitted log payload. Default 30_000 (30 seconds).
+      attr_accessor :slow_job_threshold_ms
+
+      def initialize
+        @project_token     = nil
+        @current_user      = default_current_user
+        @filter_params     = %w[
+          password password_confirmation
+          token secret authenticity_token
+          credit_card cvv ssn
+        ]
+        @max_breadcrumbs            = 20
+        @external_call_ignore_hosts = []
+        @enabled                    = true
+        @rum_enabled                = true
+        @rum_sampling_rate          = 0.1
+        @slow_job_threshold_ms      = 30_000
+      end
+
+      def valid?
+        project_token.present?
+      end
+
+      private
+
+      def default_current_user
+        lambda do |controller|
+          # Try common patterns — override in initializer if different
+          if controller.respond_to?(:current_user, true)
+            controller.send(:current_user)
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/koderift/rails/controller.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'securerandom'
+require 'koderift/rails/instrumentation'
+
+module Koderift
+  module Rails
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        around_action :koderift_instrument_request
+      end
+
+      private
+
+      def koderift_instrument_request
+        trace_id = request.headers['X-Koderift-Trace-ID'].presence ||
+                   SecureRandom.uuid
+
+        Thread.current[:koderift_trace_id] = trace_id
+        request.env['koderift.trace_id']   = trace_id
+
+        result = Koderift::Rails::Instrumentation.capture do
+          yield
+        end
+
+        request.env['koderift.spans']         = result[:spans]
+        request.env['koderift.query_count']   = result[:query_count]
+        request.env['koderift.partial_count'] = result[:partial_count]
+        request.env['koderift.search_count']  = result[:search_count]
+        request.env['koderift.breadcrumbs']   = result[:breadcrumbs]
+      ensure
+        Thread.current[:koderift_trace_id] = nil
+      end
+
+      def append_info_to_payload(payload)
+        super
+        config = Koderift::Rails.configuration
+
+        user = begin
+          config.current_user.call(self)
+        rescue StandardError
+          nil
+        end
+
+        filtered_params = request.filtered_parameters
+                                 .except('controller', 'action', 'format',
+                                         'utf8', '_method')
+                                 .reject do |k, _|
+                                   config.filter_params.any? do |f|
+                                     k.to_s.match?(/#{Regexp.escape(f)}/i)
+                                   end
+                                 end
+
+        payload[:koderift_user_id]      = user&.id
+        payload[:koderift_host]         = request.host
+        payload[:koderift_ip]           = request.remote_ip
+        payload[:koderift_user_agent]   = request.user_agent
+        payload[:koderift_request_id]   = request.request_id
+        payload[:koderift_trace_id]     = request.env['koderift.trace_id']
+        payload[:koderift_referer]      = request.referer
+        payload[:koderift_params]       = filtered_params.to_h
+        payload[:koderift_spans]         = request.env['koderift.spans']
+        payload[:koderift_query_count]   = request.env['koderift.query_count']
+        payload[:koderift_partial_count] = request.env['koderift.partial_count']
+        payload[:koderift_search_count]  = request.env['koderift.search_count']
+        payload[:koderift_breadcrumbs]   = request.env['koderift.breadcrumbs']
+      end
+    end
+  end
+end

data/lib/koderift/rails/instrumentation.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'active_support/core_ext/string/filters'
+
+module Koderift
+  module Rails
+    module Instrumentation
+      # Subscribes to Rails notifications during a request to capture
+      # partial render times, SQL query times, and breadcrumbs.
+      # Returns a hash of captured data to be merged into the log payload.
+      def self.capture
+        partials       = []
+        queries        = []
+        search_queries = []
+        breadcrumbs    = []
+        config         = Koderift::Rails.configuration
+
+        partial_sub = ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
+          event      = ActiveSupport::Notifications::Event.new(*args)
+          payload    = event.payload
+          duration   = (payload[:duration] || event.duration).round
+          identifier = payload[:identifier].to_s
+                              .sub(rails_root_prefix, '')
+                              .sub(%r{\A/app/views/}, '')
+
+          partials << { partial: identifier, duration_ms: duration }
+          breadcrumbs << {
+            type:        'render',
+            message:     identifier,
+            duration_ms: duration,
+            timestamp:   Time.now.utc.iso8601
+          }
+        end
+
+        query_sub = ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+          event   = ActiveSupport::Notifications::Event.new(*args)
+          payload = event.payload
+          next if payload[:name].to_s.match?(/\A(CACHE|SCHEMA)/)
+
+          duration = (payload[:duration] || event.duration).round
+          sql      = payload[:sql].to_s.squish.truncate(300)
+
+          queries << { sql: sql, duration_ms: duration }
+          breadcrumbs << {
+            type:        'sql',
+            message:     sql,
+            duration_ms: duration,
+            timestamp:   Time.now.utc.iso8601
+          }
+        end
+
+        # Single-model search: fired by Model.search(...)
+        # payload: { name: "Admin10 Search", query: {...} }
+        search_sub = ActiveSupport::Notifications.subscribe('search.searchkick') do |*args|
+          event    = ActiveSupport::Notifications::Event.new(*args)
+          payload  = event.payload
+          duration = (payload[:duration] || event.duration).round
+
+          index = payload[:name].to_s.sub(/\s*Search\z/i, '').strip
+          index = 'unknown' if index.blank?
+
+          search_queries << { index: index, duration_ms: duration }
+        end
+
+        # Multi search: fired by Searchkick.multi_search([...])
+        # payload: { name: "Multi Search", body: "..." }
+        # Duration covers the entire batch — record as a single entry.
+        multi_search_sub = ActiveSupport::Notifications.subscribe('multi_search.searchkick') do |*args|
+          event    = ActiveSupport::Notifications::Event.new(*args)
+          duration = event.duration.round
+
+          search_queries << { index: 'multi_search', duration_ms: duration }
+        end
+
+        external_calls = []
+        Thread.current[:koderift_external_calls]  = external_calls
+        Thread.current[:koderift_external_config] = config
+
+        begin
+          yield
+        ensure
+          ActiveSupport::Notifications.unsubscribe(partial_sub)
+          ActiveSupport::Notifications.unsubscribe(query_sub)
+          ActiveSupport::Notifications.unsubscribe(search_sub)
+          ActiveSupport::Notifications.unsubscribe(multi_search_sub)
+          Thread.current[:koderift_external_calls]  = nil
+          Thread.current[:koderift_external_config] = nil
+        end
+
+        spans = []
+
+        partials.each_with_index do |p, i|
+          spans << { type: 'partial', name: p[:partial], duration_ms: p[:duration_ms], sequence: i }
+        end
+
+        queries.each_with_index do |q, i|
+          spans << { type: 'sql', name: q[:sql], duration_ms: q[:duration_ms], sequence: i }
+        end
+
+        search_queries.each_with_index do |s, i|
+          spans << { type: 'search', name: s[:index], duration_ms: s[:duration_ms], sequence: i }
+        end
+
+        external_calls.each_with_index do |c, i|
+          spans << {
+            type:        'http',
+            name:        "#{c[:host]}#{c[:endpoint]}",
+            duration_ms: c[:duration_ms],
+            detail:      { method: c[:method], status: c[:status], trace_id: c[:trace_id] }.compact.to_json,
+            sequence:    i
+          }
+        end
+
+        {
+          spans:         spans,
+          query_count:   queries.size,
+          partial_count: partials.size,
+          search_count:  search_queries.size,
+          breadcrumbs:   breadcrumbs.last(config.max_breadcrumbs)
+        }
+      end
+
+      def self.rails_root_prefix
+        defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root ? ::Rails.root.to_s : ''
+      end
+    end
+
+    # Installed once when the gem loads (see the prepend at the bottom of this
+    # file). Writes to the thread-local external_calls array set by
+    # Instrumentation.capture; outside of a capture block it is a pass-through.
+    #
+    # CONTRACT: exactly one entry per LOGICAL outbound call. Net::HTTP#request
+    # re-enters itself whenever it is called on a session that is not started:
+    #
+    #   def request(req, body = nil, &block)
+    #     unless started?
+    #       start { req['connection'] ||= 'close'; return request(req, body, &block) }
+    #     end
+    #
+    # (net-http-0.9.1 lib/net/http.rb:2399-2405). Both frames run this prepended
+    # patch, so one call was recorded twice. That branch also forces
+    # `Connection: close` and start's ensure closes the socket, so an affected
+    # call site double-counts on EVERY call, not intermittently.
+    module NetHttpPatch
+      def request(req, *args, &block)
+        calls    = Thread.current[:koderift_external_calls]
+        config   = Thread.current[:koderift_external_config]
+        trace_id = Thread.current[:koderift_trace_id]
+
+        req['X-Koderift-Trace-ID'] = trace_id if trace_id
+
+        # Nothing below this line may run before the pass-through return: the
+        # spec stand-in defines only #request, and the header injection must
+        # still happen when instrumentation is not capturing.
+        return super(req, *args, &block) unless calls && config
+
+        # The stdlib recursion re-invokes with the SAME req object, so request
+        # identity separates "my own re-entry" from a genuinely different call
+        # issued while this one is in flight. Do NOT use `started?` (it keeps
+        # the inner frame, which cannot see connection setup, and the stand-in
+        # does not define it) and do NOT use an object ivar (one Net::HTTP
+        # shared across threads would silently lose most of its spans).
+        in_flight = (Thread.current[:koderift_http_in_flight] ||= [])
+        return super(req, *args, &block) if in_flight.any? { |r| r.equal?(req) }
+
+        in_flight << req
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          response = super(req, *args, &block)
+        ensure
+          # Strictly LIFO: the inner frame returns above without pushing, and
+          # push/pop are paired in one begin/ensure. The ensure also covers a
+          # raise (Net::OpenTimeout, ECONNREFUSED, a raising response block) --
+          # without it one failure would silence every later call on this thread.
+          in_flight.pop
+        end
+        duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+
+        host    = address.to_s
+        ignored = ['127.0.0.1', 'localhost', '[::1]'].include?(host) ||
+                  config.external_call_ignore_hosts.any? { |h| host.include?(h) }
+
+        unless ignored
+          raw_path = req.path.to_s.split('?').first.to_s
+          segments = raw_path.split('/').reject(&:empty?).first(2)
+          endpoint = segments.empty? ? '/' : '/' + segments.join('/')
+
+          calls << {
+            host: host, endpoint: endpoint, method: req.method.to_s.upcase,
+            status: response.code.to_i, duration_ms: duration, trace_id: trace_id
+          }
+        end
+
+        response
+      end
+    end
+  end
+end
+
+require 'net/http'
+Net::HTTP.prepend(Koderift::Rails::NetHttpPatch)

data/lib/koderift/rails/lograge_config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+begin
+  require 'lograge'
+rescue LoadError
+  # lograge not available — instrumentation will be skipped
+end
+
+module Koderift
+  module Rails
+    module LogrageConfig
+      MAX_FRAMES     = 50
+      LEADING_FRAMES = 10
+
+      def self.apply(app)
+        return unless defined?(Lograge)
+
+        app.config.lograge.enabled                = true
+        app.config.lograge.keep_original_rails_log = true
+        app.config.lograge.formatter              = Lograge::Formatters::Json.new
+
+        app.config.lograge.custom_options = lambda do |event|
+          exceptions = event.payload[:exception_object]
+
+          {
+            user_id:       event.payload[:koderift_user_id],
+            host:          event.payload[:koderift_host],
+            db:            event.payload[:db_runtime]&.round(2),
+            exception:     event.payload[:exception]&.join(': '),
+            request_id:    event.payload[:koderift_request_id],
+            trace_id:      event.payload[:koderift_trace_id],
+            ip:            event.payload[:koderift_ip],
+            user_agent:    event.payload[:koderift_user_agent],
+            allocations:   event.payload[:allocations],
+            error_cause:   exceptions&.cause&.message,
+            stack_trace:   format_backtrace(exceptions),
+            referer:       event.payload[:koderift_referer],
+            breadcrumbs:   event.payload[:koderift_breadcrumbs],
+            params:        event.payload[:koderift_params],
+            spans:         event.payload[:koderift_spans],
+            query_count:   event.payload[:koderift_query_count],
+            partial_count: event.payload[:koderift_partial_count],
+            search_count:  event.payload[:koderift_search_count]
+          }.compact
+        end
+      end
+
+      def self.format_backtrace(exception)
+        return nil unless exception&.backtrace&.any?
+
+        backtrace = exception.backtrace
+
+        leading = backtrace.first(LEADING_FRAMES)
+
+        rest = backtrace[LEADING_FRAMES..]&.select { |l| l.include?('/app/') } || []
+
+        frames = (leading + rest).first(MAX_FRAMES)
+
+        if frames.size < MAX_FRAMES
+          non_app_rest = backtrace[LEADING_FRAMES..]&.reject { |l| l.include?('/app/') } || []
+          frames = (frames + non_app_rest).first(MAX_FRAMES)
+        end
+
+        frames.join("\n").presence
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/koderift/rails/railtie.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Koderift
+  module Rails
+    class Railtie < ::Rails::Railtie
+      # Configure Lograge after the app initializers have run
+      # (so the user's initializer sets up Koderift.configure first)
+      initializer 'koderift.configure_lograge', after: :load_config_initializers do |app|
+        next unless Koderift::Rails.configuration.enabled
+
+        require 'koderift/rails/lograge_config'
+        Koderift::Rails::LogrageConfig.apply(app)
+      end
+
+      # Include the controller concern into ActionController::Base
+      initializer 'koderift.include_controller', after: :load_config_initializers do
+        next unless Koderift::Rails.configuration.enabled
+
+        ActiveSupport.on_load(:action_controller_base) do
+          require 'koderift/rails/controller'
+          include Koderift::Rails::Controller
+        end
+      end
+
+      # Make koderift_rum_meta_tag available in all views
+      initializer 'koderift.helpers', after: :load_config_initializers do
+        next unless Koderift::Rails.configuration.enabled
+
+        ActiveSupport.on_load(:action_view) do
+          require 'koderift/rails/rum_helper'
+          include Koderift::Rails::RumHelper
+        end
+      end
+
+      # Register Sidekiq server middleware lazily when Sidekiq is present.
+      initializer 'koderift.sidekiq_middleware', after: :load_config_initializers do
+        next unless Koderift::Rails.configuration.enabled
+
+        ActiveSupport.on_load(:after_initialize) do
+          if defined?(Sidekiq) && Sidekiq.respond_to?(:configure_server)
+            require 'koderift/rails/sidekiq_middleware'
+            Sidekiq.configure_server do |sidekiq_config|
+              sidekiq_config.server_middleware do |chain|
+                chain.add Koderift::Rails::SidekiqMiddleware
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/koderift/rails/rum_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Koderift
+  module Rails
+    module RumHelper
+      # Renders the meta tag that rum.js reads for initialisation.
+      # Place once inside <head> in your application layout.
+      #
+      # Example:
+      #   <%= koderift_rum_meta_tag %>
+      #
+      # Renders:
+      #   <meta name="koderift-rum-token"
+      #         content="abc123"
+      #         data-rum-sampling-rate="0.1"
+      #         data-environment="production">
+      #
+      # Returns an empty string when RUM is disabled or no token is configured.
+      def koderift_rum_meta_tag
+        config = Koderift::Rails.configuration
+        return ''.html_safe unless config.rum_enabled && config.project_token.present?
+
+        tag.meta(
+          name:    'koderift-rum-token',
+          content: config.project_token,
+          data: {
+            rum_sampling_rate: config.rum_sampling_rate.to_f,
+            environment:       (defined?(::Rails) && ::Rails.respond_to?(:env) ? ::Rails.env.to_s : 'production')
+          }
+        )
+      end
+    end
+  end
+end

data/lib/koderift/rails/sidekiq_middleware.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'koderift/rails/instrumentation'
+
+module Koderift
+  module Rails
+    # Sidekiq server middleware that wraps each job in Instrumentation.capture
+    # and writes a single JSON line to Rails.logger. The koderift-agent picks
+    # this up via the existing Rails log tailer — the "job_class" key
+    # distinguishes it from Lograge request lines.
+    class SidekiqMiddleware
+      def call(worker, job, queue)
+        config = Koderift::Rails.configuration
+        return yield unless config.enabled && config.project_token.present?
+
+        trace_id = job['koderift_trace_id'].to_s
+        trace_id = SecureRandom.uuid if trace_id.empty?
+        Thread.current[:koderift_trace_id] = trace_id
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        begin
+          result = Instrumentation.capture { yield }
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+          emit_job_log(worker, job, queue, result, duration_ms, trace_id, error: nil)
+          result
+        rescue StandardError => e
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+          empty_result = { spans: [], query_count: 0, partial_count: 0,
+                           search_count: 0, breadcrumbs: [] }
+          emit_job_log(worker, job, queue, empty_result, duration_ms, trace_id, error: e)
+          raise
+        ensure
+          Thread.current[:koderift_trace_id] = nil
+        end
+      end
+
+      private
+
+      def emit_job_log(_worker, job, queue, result, duration_ms, trace_id, error:)
+        config = Koderift::Rails.configuration
+
+        level = if error
+          'error'
+        elsif duration_ms >= config.slow_job_threshold_ms
+          'slow'
+        else
+          'info'
+        end
+
+        payload = {
+          job_class:    job['class'].to_s,
+          jid:          job['jid'].to_s,
+          queue:        queue.to_s,
+          status:       error ? 500 : 200,
+          duration:     duration_ms,
+          level:        level,
+          trace_id:     trace_id,
+          spans:        result[:spans],
+          query_count:  result[:query_count],
+          search_count: result[:search_count],
+          breadcrumbs:  result[:breadcrumbs]
+        }
+
+        if error
+          payload[:exception] = "#{error.class}: #{error.message}"
+          bt = error.backtrace&.first(20)&.join("\n")
+          payload[:stack_trace] = bt if bt && !bt.empty?
+        end
+
+        ::Rails.logger.info(payload.compact.to_json)
+      rescue StandardError => e
+        ::Rails.logger.warn("[KoderiftSidekiqMiddleware] emit failed: #{e.message}")
+      end
+    end
+  end
+end

data/lib/koderift/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Koderift
+  module Rails
+    VERSION = '1.3.4'
+  end
+end

data/lib/koderift/rails.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'koderift/rails/version'
+require 'koderift/rails/configuration'
+require 'koderift/rails/instrumentation'
+require 'koderift/rails/lograge_config'
+require 'koderift/rails/controller'
+require 'koderift/rails/rum_helper'
+require 'koderift/rails/railtie' if defined?(::Rails::Railtie)
+
+module Koderift
+  module Rails
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def reset!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end

data/lib/koderift-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'koderift/rails'

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: koderift-rails
+version: !ruby/object:Gem::Version
+  version: 1.3.4
+platform: ruby
+authors:
+- Koderift
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: lograge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: Automatically captures request context, performance data, and error information
+  for Koderift log analytics.
+email:
+- support@koderift.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/koderift-rails.rb
+- lib/koderift/rails.rb
+- lib/koderift/rails/configuration.rb
+- lib/koderift/rails/controller.rb
+- lib/koderift/rails/instrumentation.rb
+- lib/koderift/rails/lograge_config.rb
+- lib/koderift/rails/railtie.rb
+- lib/koderift/rails/rum_helper.rb
+- lib/koderift/rails/sidekiq_middleware.rb
+- lib/koderift/rails/version.rb
+homepage: https://github.com/koderift/koderift-rails
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/koderift/koderift-rails
+  changelog_uri: https://github.com/koderift/koderift-rails/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/koderift/koderift-rails/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Rails instrumentation for Koderift log analytics
+test_files: []