catpm 0.10.1 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dab2a97464afff0ad59e3913f7f1aca84505d3ca109966a611eed911d5bb1a7
-  data.tar.gz: aa4c892ce8a39fb2ba5ceacf1aef5f1b9c6c867a682536f67c895d887d93607b
+  metadata.gz: c4147059f707d6d81dfc82021c4c56344701560054f5f11b1fb5411b58d94f2e
+  data.tar.gz: ce4180ae0fde1b5300d67d4919ff7883204ea61bcc2fe4b13d23fc8471abef2a
 SHA512:
-  metadata.gz: dbfa610b0355bf1f99b41c6be9476f622e4f756c75c79764abee15721bb2a729113425b6b81416e86e09f734d253301c36f8b0f577b8b15075c584d0e0728dae
-  data.tar.gz: ebaef872bc07283485e72ef2ccb5b9f14b836f581c66053ed0f7329621e83a5b7e3b58ef7e021cb43c5bdece61d20dda39867c85a73382bef055364424481f16
+  metadata.gz: 39314b333fefeab949b3cb10948e8efa5dd09fd51bf77194e7cc0542e159d1a693d83fea4fdbd7272e0968915154d68387a0e49bc0c28f10e0eb33d2934ae3db
+  data.tar.gz: ff02750df626ada2511ba6ead16311d8ea5afe42835b25a031328e765a432c7839dabdacc336e4a07ba0d69fffcac07b0795b767ca7905de4b8cc36cc2f81a11

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.10.0.gem
+gem push catpm-0.10.2.gem
 
 # Catpm
 

data/lib/catpm/collector.rb

@@ -201,6 +201,10 @@ module Catpm
 
         duration = event.duration
         exception = payload[:exception_object]
+        owns_segments = payload[:_catpm_job_owns_segments]
+
+        req_segments = Thread.current[:catpm_request_segments] if owns_segments
+        instrumented = !req_segments.nil?
 
         queue_wait = if job.respond_to?(:enqueued_at) && job.enqueued_at
           ((Time.current - job.enqueued_at.to_time) * 1000.0) rescue nil
@@ -208,21 +212,110 @@ module Catpm
 
         metadata = { queue_wait: queue_wait }.compact
 
+        if req_segments
+          segment_data = req_segments.to_h
+          segment_data[:segment_summary].each { |k, v| metadata[k] = v }
+        end
+
+        metadata[:_instrumented] = 1 if instrumented
+
         sample_type = early_sample_type(
           error: exception,
           duration: duration,
           kind: :job,
           target: target,
-          operation: job.queue_name
+          operation: job.queue_name,
+          instrumented: instrumented
         )
 
-        context = if sample_type
-          {
+        context = nil
+        if sample_type
+          context = {
             job_class: target,
             job_id: job.job_id,
             queue: job.queue_name,
             attempts: job.executions
           }
+
+          if req_segments
+            segments = segment_data[:segments]
+            collapse_code_wrappers(segments)
+
+            # Inject root job segment with full duration
+            root_segment = {
+              type: 'request',
+              detail: "job #{target}",
+              duration: duration.round(2),
+              offset: 0.0
+            }
+            segments.each do |seg|
+              if seg.key?(:parent_index)
+                seg[:parent_index] += 1
+              else
+                seg[:parent_index] = 0
+              end
+            end
+            segments.unshift(root_segment)
+
+            # Inject call tree segments from sampler
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if Catpm.config.instrument_call_tree && req_segments
+              tree_segs = req_segments.call_tree_segments
+              if tree_segs.any?
+                base_idx = segments.size
+                tree_segs.each do |seg|
+                  tree_parent = seg.delete(:_tree_parent)
+                  seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
+                  segments << seg
+                end
+                reparent_under_call_tree(segments, ctrl_idx)
+              end
+            end
+
+            # Fill untracked controller time with sampler data or synthetic segment
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if ctrl_idx
+              ctrl_seg = segments[ctrl_idx]
+              ctrl_dur = (ctrl_seg[:duration] || 0).to_f
+              child_dur = segments.each_with_index.sum do |pair|
+                seg, i = pair
+                next 0.0 if i == ctrl_idx
+                (seg[:parent_index] == ctrl_idx) ? (seg[:duration] || 0).to_f : 0.0
+              end
+              gap = ctrl_dur - child_dur
+
+              if gap > MIN_GAP_MS && Catpm.config.show_untracked_segments
+                inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
+              end
+            end
+
+            context[:segments] = segments
+            context[:segment_summary] = segment_data[:segment_summary]
+            context[:segments_capped] = segment_data[:segments_capped]
+            context[:segments_filtered] = segment_data[:segments_filtered] if segment_data[:segments_filtered] > 0
+
+            # Append error marker segment inside the controller
+            if exception
+              error_parent = ctrl_idx || 0
+              error_offset = if ctrl_idx
+                ctrl = segments[ctrl_idx]
+                ((ctrl[:offset] || 0) + (ctrl[:duration] || 0)).round(2)
+              else
+                duration.round(2)
+              end
+
+              context[:segments] << {
+                type: 'error',
+                detail: "#{exception.class.name}: #{exception.message}".truncate(Catpm.config.max_error_detail_length),
+                source: exception.backtrace&.first,
+                duration: 0,
+                offset: error_offset,
+                parent_index: error_parent
+              }
+            end
+          end
+
+          context = scrub(context)
         end
 
         ev = Event.new(
@@ -240,6 +333,12 @@ module Catpm
         )
 
         Catpm.buffer&.push(ev)
+      ensure
+        if owns_segments
+          req_segments&.release!
+          Collector.end_instrumentation
+          Thread.current[:catpm_request_segments] = nil
+        end
       end
 
       def process_tracked(kind:, target:, operation:, duration:, context:, metadata:, error:, req_segments:)
@@ -439,6 +538,11 @@ module Catpm
       # Re-parent non-code segments (sql, cache, etc.) under call tree code segments
       # when their offset falls within the code segment's time range.
       # This gives proper nesting: code → sql, instead of both being siblings under controller.
+      #
+      # After reparenting, extends code segment durations up the call tree chain
+      # when children (e.g. external HTTP spans) extend beyond the code segment's
+      # sampler-derived duration. This happens because the stack sampler may hit its
+      # sample cap before the code finishes (e.g. during a long I/O call).
       def reparent_under_call_tree(segments, ctrl_idx)
         # Build index of code segments with their time ranges: [index, offset, end]
         code_nodes = []
@@ -448,6 +552,12 @@ module Catpm
         end
         return if code_nodes.empty?
 
+        # Tolerance for offset matching: spans created via push_span record exact timing,
+        # while call tree code segments start from the first sampler capture (up to one
+        # sampling interval later). Without tolerance, the span's offset falls just before
+        # the code segment's range and reparenting silently fails.
+        sampling_tolerance_ms = Catpm.config.stack_sample_interval * 1000.0
+
         segments.each_with_index do |seg, i|
           # Only reparent direct children of controller that aren't code segments
           next if seg[:type] == 'code' || seg[:type] == 'controller' || seg[:type] == 'request'
@@ -462,7 +572,7 @@ module Catpm
           best_dur = Float::INFINITY
 
           code_nodes.each do |code_i, code_start, code_end|
-            next unless seg_offset >= code_start && seg_offset < code_end
+            next unless seg_offset >= (code_start - sampling_tolerance_ms) && seg_offset < code_end
 
             dur = code_end - code_start
             if dur < best_dur
@@ -473,6 +583,52 @@ module Catpm
 
           seg[:parent_index] = best_idx if best_idx
         end
+
+        # Extend code segment durations when reparented children extend beyond them.
+        # The stack sampler may hit its cap early, producing short code segments that
+        # don't cover the full wall-clock time of long I/O calls within them.
+        extend_call_tree_durations(segments)
+      end
+
+      # Walk all segments; when a child's end time exceeds its parent code segment's
+      # end time, extend the parent (and propagate up the chain).
+      def extend_call_tree_durations(segments)
+        segments.each do |seg|
+          parent_idx = seg[:parent_index]
+          next unless parent_idx
+
+          parent = segments[parent_idx]
+          next unless parent && parent[:type] == 'code'
+
+          seg_end = (seg[:offset] || 0).to_f + (seg[:duration] || 0).to_f
+          parent_offset = (parent[:offset] || 0).to_f
+          parent_end = parent_offset + (parent[:duration] || 0).to_f
+
+          next unless seg_end > parent_end
+
+          parent[:duration] = (seg_end - parent_offset).round(2)
+
+          # Propagate up the call tree chain
+          propagate_duration_up(segments, parent_idx)
+        end
+      end
+
+      def propagate_duration_up(segments, idx)
+        seg = segments[idx]
+        parent_idx = seg[:parent_index]
+        return unless parent_idx
+
+        parent = segments[parent_idx]
+        return unless parent && parent[:type] == 'code'
+
+        seg_end = (seg[:offset] || 0).to_f + (seg[:duration] || 0).to_f
+        parent_offset = (parent[:offset] || 0).to_f
+        parent_end = parent_offset + (parent[:duration] || 0).to_f
+
+        return unless seg_end > parent_end
+
+        parent[:duration] = (seg_end - parent_offset).round(2)
+        propagate_duration_up(segments, parent_idx)
       end
 
       # Remove near-zero-duration "code" spans that merely wrap a "controller" span.

data/lib/catpm/segment_subscribers.rb

@@ -51,6 +51,51 @@ module Catpm
       end
     end
 
+    # Subscriber with start/finish callbacks so all segments (SQL, cache, etc.)
+    # fired during a job are automatically captured and nested under the job span.
+    class JobSpanSubscriber
+      def start(_name, _id, payload)
+        return unless Catpm.config.instrument_segments
+
+        job = payload[:job]
+        target = job.class.name
+        return if Catpm.config.ignored?(target)
+
+        # Mark that we're inside a job so nested Catpm.span calls don't
+        # promote themselves to standalone endpoints when this job is not
+        # selected for segment sampling.
+        Thread.current[:catpm_job_active] = true
+
+        if Collector.should_instrument?(:job, target, job.queue_name)
+          use_sampler = Catpm.config.instrument_stack_sampler || Catpm.config.instrument_call_tree
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          req_segments = RequestSegments.new(
+            max_segments: Catpm.config.effective_max_segments_per_request,
+            request_start: start_time,
+            stack_sample: use_sampler,
+            call_tree: Catpm.config.instrument_call_tree
+          )
+          Thread.current[:catpm_request_segments] = req_segments
+
+          index = req_segments.push_span(type: :controller, detail: target, started_at: start_time)
+          payload[:_catpm_job_span_index] = index
+          payload[:_catpm_job_owns_segments] = true
+        end
+      end
+
+      def finish(_name, _id, payload)
+        Thread.current[:catpm_job_active] = nil
+
+        return unless payload[:_catpm_job_owns_segments]
+
+        req_segments = Thread.current[:catpm_request_segments]
+        return unless req_segments
+
+        req_segments.pop_span(payload[:_catpm_job_span_index])
+        req_segments.stop_sampler
+      end
+    end
+
     IGNORED_SQL_NAMES = Set.new([
       'SCHEMA', 'EXPLAIN',
       'ActiveRecord::SchemaMigration Load',
@@ -65,6 +110,12 @@ module Catpm
           'process_action.action_controller', ControllerSpanSubscriber.new
         )
 
+        if Catpm.config.instrument_jobs
+          @job_span_subscriber = ActiveSupport::Notifications.subscribe(
+            'perform.active_job', JobSpanSubscriber.new
+          )
+        end
+
         @sql_subscriber = ActiveSupport::Notifications.subscribe(
           'sql.active_record'
         ) do |event|
@@ -122,7 +173,7 @@ module Catpm
 
       def unsubscribe!
         [
-          @controller_span_subscriber,
+          @controller_span_subscriber, @job_span_subscriber,
           @sql_subscriber, @instantiation_subscriber,
           @render_template_subscriber, @render_partial_subscriber,
           @cache_read_subscriber, @cache_write_subscriber,
@@ -131,6 +182,7 @@ module Catpm
           ActiveSupport::Notifications.unsubscribe(sub) if sub
         end
         @controller_span_subscriber = nil
+        @job_span_subscriber = nil
         @sql_subscriber = nil
         @instantiation_subscriber = nil
         @render_template_subscriber = nil

data/lib/catpm/trace.rb

@@ -9,9 +9,9 @@ module Catpm
 
     req_segments = Thread.current[:catpm_request_segments]
     unless req_segments
-      # Inside a non-instrumented HTTP request — just run the block
+      # Inside a non-instrumented request/job — just run the block
       # without promoting the span to a standalone endpoint
-      if Thread.current[:catpm_request_start]
+      if Thread.current[:catpm_request_start] || Thread.current[:catpm_job_active]
         return block.call if block
         return nil
       end
@@ -52,7 +52,7 @@ module Catpm
           type: :custom, duration: duration_ms, detail: name,
           source: source, started_at: start_time
         )
-      elsif buffer && !Thread.current[:catpm_request_start]
+      elsif buffer && !Thread.current[:catpm_request_start] && !Thread.current[:catpm_job_active]
         Collector.process_custom(
           name: name, duration: duration_ms,
           metadata: metadata, error: error, context: context
@@ -155,7 +155,7 @@ module Catpm
           type: :custom, duration: duration_ms, detail: @name,
           source: source, started_at: @start_time
         )
-      elsif Catpm.enabled? && Catpm.buffer && !Thread.current[:catpm_request_start]
+      elsif Catpm.enabled? && Catpm.buffer && !Thread.current[:catpm_request_start] && !Thread.current[:catpm_job_active]
         Collector.process_custom(
           name: @name, duration: duration_ms,
           metadata: @metadata, error: error, context: @context

data/lib/catpm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Catpm
-  VERSION = '0.10.1'
+  VERSION = '0.10.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.3
 platform: ruby
 authors:
 - ''