koderift-rails 1.3.4 → 2.1.0

data/lib/koderift/rails/instrumentation.rb

@@ -10,11 +10,28 @@ module Koderift
       # partial render times, SQL query times, and breadcrumbs.
       # Returns a hash of captured data to be merged into the log payload.
       def self.capture
+        state = start_capture
+        begin
+          yield
+        ensure
+          stop_capture(state)
+        end
+        build_result(state)
+      end
+
+      # capture's three phases, exposed separately so a unit of work that is
+      # NOT a block runs through the same subscriptions rather than a parallel
+      # implementation. Tracing::Transaction is that caller: it has to be
+      # started and finished by two separate calls to mirror Sentry's
+      # start_transaction / finish, which a block-shaped API cannot express.
+      def self.start_capture
+        config         = Koderift::Rails.configuration
         partials       = []
         queries        = []
         search_queries = []
         breadcrumbs    = []
-        config         = Koderift::Rails.configuration
+        custom_spans   = []
+        external_calls = []
 
         partial_sub = ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
           event      = ActiveSupport::Notifications::Event.new(*args)
@@ -73,36 +90,54 @@ module Koderift
           search_queries << { index: 'multi_search', duration_ms: duration }
         end
 
-        external_calls = []
+        # Published for the same reason external_calls is: code that runs
+        # somewhere else entirely — the Net::HTTP patch, Koderift.add_breadcrumb,
+        # Koderift.with_child_span — has no other way to find the collection
+        # belonging to the unit of work currently in flight on this thread.
+        Thread.current[:koderift_breadcrumbs]     = breadcrumbs
+        Thread.current[:koderift_custom_spans]    = custom_spans
         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
+        {
+          config:         config,
+          partials:       partials,
+          queries:        queries,
+          search_queries: search_queries,
+          breadcrumbs:    breadcrumbs,
+          custom_spans:   custom_spans,
+          external_calls: external_calls,
+          subscriptions:  [partial_sub, query_sub, search_sub, multi_search_sub]
+        }
+      end
+
+      def self.stop_capture(state)
+        state[:subscriptions].each do |sub|
+          ActiveSupport::Notifications.unsubscribe(sub)
         end
+        Thread.current[:koderift_breadcrumbs]     = nil
+        Thread.current[:koderift_custom_spans]    = nil
+        Thread.current[:koderift_external_calls]  = nil
+        Thread.current[:koderift_external_config] = nil
+        state
+      end
 
+      def self.build_result(state)
         spans = []
 
-        partials.each_with_index do |p, i|
+        state[: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|
+        state[: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|
+        state[: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|
+        state[:external_calls].each_with_index do |c, i|
           spans << {
             type:        'http',
             name:        "#{c[:host]}#{c[:endpoint]}",
@@ -112,12 +147,22 @@ module Koderift
           }
         end
 
+        state[:custom_spans].each_with_index do |c, i|
+          spans << {
+            type:        'custom',
+            name:        c[:name],
+            duration_ms: c[:duration_ms],
+            detail:      c[:detail],
+            sequence:    i
+          }.compact
+        end
+
         {
           spans:         spans,
-          query_count:   queries.size,
-          partial_count: partials.size,
-          search_count:  search_queries.size,
-          breadcrumbs:   breadcrumbs.last(config.max_breadcrumbs)
+          query_count:   state[:queries].size,
+          partial_count: state[:partials].size,
+          search_count:  state[:search_queries].size,
+          breadcrumbs:   state[:breadcrumbs].last(state[:config].max_breadcrumbs)
         }
       end
 

data/lib/koderift/rails/lograge_config.rb

@@ -46,9 +46,14 @@ module Koderift
       end
 
       def self.format_backtrace(exception)
-        return nil unless exception&.backtrace&.any?
+        format_frames(exception&.backtrace)
+      end
 
-        backtrace = exception.backtrace
+      # Split out from format_backtrace so a caller holding a raw backtrace
+      # array -- Capture, when given an explicit `backtrace:` -- gets the same
+      # frame selection instead of a second, subtly different implementation.
+      def self.format_frames(backtrace)
+        return nil unless backtrace.is_a?(Array) && backtrace.any?
 
         leading = backtrace.first(LEADING_FRAMES)
 

data/lib/koderift/rails/railtie.rb

@@ -34,6 +34,20 @@ module Koderift
         end
       end
 
+      # Capture uncaught rake task failures. Rake is loaded before the Rails
+      # environment under `bundle exec rake` / `bin/rails <task>`, so the
+      # constant is present by the time initializers run; under a web server it
+      # is not, and the guard makes this a no-cost skip.
+      initializer 'koderift.rake_integration', after: :load_config_initializers do
+        next unless Koderift::Rails.configuration.enabled
+        next unless defined?(::Rake::Application)
+
+        require 'koderift/rails/rake_integration'
+        unless ::Rake::Application.include?(Koderift::Rails::RakeIntegration)
+          ::Rake::Application.prepend(Koderift::Rails::RakeIntegration)
+        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

data/lib/koderift/rails/rake_integration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Koderift
+  module Rails
+    # Captures uncaught rake task failures.
+    #
+    # This closes the largest blind spot in the product for scheduled work. A
+    # rake task that raises writes its backtrace to STDERR, which under cron
+    # goes to a mail spool or /dev/null — never to production.log — so the log
+    # agent has never seen it and Koderift has never reported it. The tasks
+    # most likely to fail unnoticed are exactly the ones nobody has touched in
+    # a year.
+    #
+    # Rake::Application#display_error_message is the hook Sentry uses for the
+    # same purpose. We capture and then call super, so Rake's own error output
+    # is completely unchanged — anything already scraping that output, or a
+    # human reading the cron mail, sees exactly what it saw before.
+    module RakeIntegration
+      def display_error_message(exception)
+        Koderift::Rails::RakeIntegration.report(exception)
+        super
+      end
+
+      # A clean `exit` inside a task reaches this hook as a SystemExit. It is
+      # the task finishing, not failing, and reporting it would file an error
+      # for every well-behaved task that exits explicitly.
+      def self.report(exception)
+        return if exception.is_a?(SystemExit)
+
+        Koderift.capture_exception(exception, component: task_name, action: 'rake')
+      rescue StandardError
+        nil
+      end
+
+      def self.task_name
+        name = ::Rake.application.top_level_tasks.first.to_s
+        name.empty? ? 'rake' : name
+      rescue StandardError
+        'rake'
+      end
+    end
+  end
+end

data/lib/koderift/rails/rum_helper.rb

@@ -3,6 +3,18 @@
 module Koderift
   module Rails
     module RumHelper
+      MISSING_RUM_TOKEN_WARNING =
+        '[Koderift] Browser RUM is off: koderift_rum_meta_tag renders nothing until ' \
+        'config.rum_token is set. Since koderift-rails 2.1 the tag no longer publishes ' \
+        'config.project_token, which is a secret. Copy the public RUM token (it starts ' \
+        "with rum_) from your project's Log Analytics setup page in Koderift, or set " \
+        'config.rum_enabled = false.'
+
+      SECRET_RUM_TOKEN_WARNING =
+        '[Koderift] Browser RUM is off: config.rum_token is set to your project token, ' \
+        'which is a secret and must not appear in page HTML. Use the public RUM token ' \
+        "(it starts with rum_) from your project's Log Analytics setup page in Koderift."
+
       # Renders the meta tag that rum.js reads for initialisation.
       # Place once inside <head> in your application layout.
       #
@@ -11,24 +23,68 @@ module Koderift
       #
       # Renders:
       #   <meta name="koderift-rum-token"
-      #         content="abc123"
+      #         content="rum_abc123"
       #         data-rum-sampling-rate="0.1"
       #         data-environment="production">
       #
-      # Returns an empty string when RUM is disabled or no token is configured.
+      # Publishes config.rum_token only, never config.project_token. Returns an
+      # empty string when RUM is disabled or there is no publishable token.
       def koderift_rum_meta_tag
         config = Koderift::Rails.configuration
-        return ''.html_safe unless config.rum_enabled && config.project_token.present?
+        return ''.html_safe unless config.rum_enabled
+
+        token = RumHelper.publishable_rum_token(config)
+        return ''.html_safe unless token
 
         tag.meta(
           name:    'koderift-rum-token',
-          content: config.project_token,
+          content: token,
           data: {
             rum_sampling_rate: config.rum_sampling_rate.to_f,
             environment:       (defined?(::Rails) && ::Rails.respond_to?(:env) ? ::Rails.env.to_s : 'production')
           }
         )
       end
+
+      class << self
+        # The token the meta tag may publish, or nil. Up to 2.0 the tag published
+        # project_token, the log agent's ingest secret. It never does now, and a
+        # rum_token equal to it is refused for the same reason. There is
+        # deliberately no fallback: an app that set up RUM before 2.1 and has
+        # not set rum_token gets one warning per process instead.
+        def publishable_rum_token(config)
+          token  = config.rum_token.to_s
+          secret = config.project_token.to_s
+
+          if token.empty?
+            warn_once(MISSING_RUM_TOKEN_WARNING) unless secret.empty?
+            return nil
+          end
+
+          if token == secret
+            warn_once(SECRET_RUM_TOKEN_WARNING)
+            return nil
+          end
+
+          token
+        end
+
+        def reset_warnings!
+          @warned = false
+        end
+
+        private
+
+        def warn_once(message)
+          return if @warned
+
+          @warned = true
+          logger = defined?(::Rails) && ::Rails.respond_to?(:logger) ? ::Rails.logger : nil
+          logger&.warn(message)
+        rescue StandardError
+          nil
+        end
+      end
     end
   end
 end

data/lib/koderift/rails/scope.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'koderift/rails/breadcrumb'
+
+module Koderift
+  module Rails
+    # Sentry-compatible scope: ambient user/tags/extras/contexts merged into
+    # every capture made while it is current.
+    #
+    # The stack is thread-local, and it is RESET at the end of every request and
+    # Sidekiq job (see Controller and SidekiqMiddleware). That reset is not
+    # housekeeping: Puma and Sidekiq both reuse threads, so without it a tag set
+    # for one user's request would silently attach to the next request served by
+    # that thread.
+    class Scope
+      STACK_KEY = :koderift_scope_stack
+
+      attr_reader :user, :tags, :extras, :contexts
+      attr_accessor :level, :fingerprint, :component, :action
+
+      def initialize
+        @user        = {}
+        @tags        = {}
+        @extras      = {}
+        @contexts    = {}
+        @level       = nil
+        @fingerprint = nil
+        @component   = nil
+        @action      = nil
+      end
+
+      class << self
+        def stack
+          Thread.current[STACK_KEY] ||= [new]
+        end
+
+        def current
+          stack.last
+        end
+
+        def push
+          stack.push(current.dup)
+          current
+        end
+
+        def pop
+          stack.pop if stack.size > 1
+          current
+        end
+
+        def reset!
+          Thread.current[STACK_KEY] = nil
+        end
+
+        # Runs `block` against a temporary copy of the current scope before
+        # yielding, so `capture_exception(e) { |scope| scope.set_tags(...) }`
+        # cannot leak those tags into later captures on the same thread.
+        def with_temporary(block)
+          return yield unless block
+
+          push
+          begin
+            block.call(current)
+            yield
+          ensure
+            pop
+          end
+        end
+      end
+
+      def set_user(hash)
+        @user = stringify(hash)
+        self
+      end
+
+      def set_tags(hash)
+        @tags.merge!(stringify(hash))
+        self
+      end
+
+      def set_tag(key, value)
+        @tags[key.to_s] = value
+        self
+      end
+
+      def set_extras(hash)
+        @extras.merge!(stringify(hash))
+        self
+      end
+
+      def set_extra(key, value)
+        @extras[key.to_s] = value
+        self
+      end
+
+      def set_context(key, value)
+        @contexts[key.to_s] = value
+        self
+      end
+
+      def set_contexts(hash)
+        @contexts.merge!(stringify(hash))
+        self
+      end
+
+      def set_level(level)
+        @level = level
+        self
+      end
+
+      def set_fingerprint(fingerprint)
+        @fingerprint = fingerprint
+        self
+      end
+
+      # Sentry's transaction name is "Controller#action". Koderift stores those
+      # as two separate columns and groups errors on them, so split rather than
+      # keep the joined string.
+      def set_transaction_name(name)
+        component, _, action = name.to_s.partition('#')
+        @component = component.empty? ? nil : component
+        @action    = action.empty?    ? nil : action
+        self
+      end
+
+      def add_breadcrumb(crumb)
+        Breadcrumbs.add(crumb)
+        self
+      end
+
+      def clear_breadcrumbs
+        Breadcrumbs.clear
+        self
+      end
+
+      def clear
+        initialize
+        self
+      end
+
+      def dup
+        copy = self.class.new
+        copy.set_user(@user)
+        copy.set_tags(@tags)
+        copy.set_extras(@extras)
+        copy.set_contexts(@contexts)
+        copy.level       = @level
+        copy.fingerprint = @fingerprint
+        copy.component   = @component
+        copy.action      = @action
+        copy
+      end
+
+      private
+
+      def stringify(hash)
+        return {} unless hash.respond_to?(:each_pair)
+
+        hash.each_with_object({}) { |(k, v), out| out[k.to_s] = v }
+      end
+    end
+  end
+end

data/lib/koderift/rails/sidekiq_middleware.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'securerandom'
 require 'koderift/rails/instrumentation'
+require 'koderift/rails/scope'
 
 module Koderift
   module Rails
@@ -19,6 +20,16 @@ module Koderift
         trace_id = SecureRandom.uuid if trace_id.empty?
         Thread.current[:koderift_trace_id] = trace_id
 
+        # Ambient context for manual captures made anywhere inside the job.
+        # The jid stands in for a request id: it is what correlates a capture
+        # with the job's own log line, and what carries this job's spans into
+        # log_spans (IngestLogBatchJob drops spans on a row with no request id).
+        Thread.current[:koderift_context] = {
+          component:  job_name(job),
+          action:     'perform',
+          request_id: job['jid'].to_s
+        }
+
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         begin
@@ -34,11 +45,23 @@ module Koderift
           raise
         ensure
           Thread.current[:koderift_trace_id] = nil
+          Thread.current[:koderift_context]  = nil
+          # Sidekiq reuses threads across jobs; see the same reset in Controller.
+          Koderift::Rails::Scope.reset!
         end
       end
 
       private
 
+      # The name Sidekiq's own JobLogger logs the job under. For ActiveJob,
+      # job['class'] is the adapter's wrapper (Sidekiq::ActiveJob::Wrapper,
+      # ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper) for every job, and
+      # job['wrapped'] is the job itself. Matching Sidekiq also lets the agent
+      # pair this line with Sidekiq's "done" line for the same attempt.
+      def job_name(job)
+        (job['wrapped'] || job['class']).to_s
+      end
+
       def emit_job_log(_worker, job, queue, result, duration_ms, trace_id, error:)
         config = Koderift::Rails.configuration
 
@@ -51,7 +74,7 @@ module Koderift
         end
 
         payload = {
-          job_class:    job['class'].to_s,
+          job_class:    job_name(job),
           jid:          job['jid'].to_s,
           queue:        queue.to_s,
           status:       error ? 500 : 200,