catpm 0.10.3 → 0.11.0

data/lib/catpm/middleware.rb

@@ -13,6 +13,7 @@ module Catpm
 
       env['catpm.request_start'] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       Thread.current[:catpm_request_start] = env['catpm.request_start']
+      Thread.current[:catpm_request_env] = env
 
       if Catpm.config.instrument_segments && Collector.should_instrument_request?
         use_sampler = Catpm.config.instrument_stack_sampler || Catpm.config.instrument_call_tree
@@ -36,6 +37,7 @@ module Catpm
       Collector.end_instrumentation if req_segments
       Thread.current[:catpm_request_segments] = nil
       Thread.current[:catpm_request_start] = nil
+      Thread.current[:catpm_request_env] = nil
       Thread.current[:catpm_tracked_instrumented] = nil
     end
 
@@ -55,10 +57,7 @@ module Catpm
         error_class: exception.class.name,
         error_message: exception.message,
         backtrace: exception.backtrace,
-        context: {
-          method: env['REQUEST_METHOD'],
-          path: env['PATH_INFO']
-        }
+        context: Collector.build_exception_context(env)
       )
 
       Catpm.buffer.push(ev)

data/lib/catpm/request_segments.rb

@@ -18,6 +18,7 @@ module Catpm
       @overflow = false
       @summary = Hash.new(0)
       @span_stack = []
+      @span_children_duration = {} # span_index => accumulated direct children duration
       @tracked_ranges = []
       @call_tree = call_tree
       @estimated_bytes = 0
@@ -35,6 +36,11 @@ module Catpm
       @summary[count_key] += 1
       @summary[dur_key] += duration
 
+      # Attribute this leaf duration to immediate parent span for self-time calculation
+      if @span_stack.any?
+        @span_children_duration[@span_stack.last] += duration
+      end
+
       # Record time range so sampler can skip already-tracked periods
       if started_at && duration > 0
         @tracked_ranges << [started_at, started_at + duration / 1000.0]
@@ -79,6 +85,7 @@ module Catpm
       index = @segments.size
       @segments << segment
       @span_stack.push(index)
+      @span_children_duration[index] = 0.0
       @estimated_bytes += estimate_segment_bytes(segment)
       index
     end
@@ -99,10 +106,19 @@ module Catpm
       duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000.0
       segment[:duration] = duration.round(2)
 
+      # Self-time = total duration minus direct children (avoids double-counting in breakdown)
+      children_dur = @span_children_duration.delete(index) || 0.0
+      self_duration = [duration - children_dur, 0.0].max
+
+      # Report total duration to parent span so it can compute its own self-time
+      if @span_stack.any?
+        @span_children_duration[@span_stack.last] += duration
+      end
+
       type_key = segment[:type].to_sym
       count_key, dur_key = SUMMARY_KEYS[type_key]
       @summary[count_key] += 1
-      @summary[dur_key] += duration
+      @summary[dur_key] += self_duration
     end
 
     def stop_sampler
@@ -128,6 +144,7 @@ module Catpm
     def release!
       @segments = []
       @summary = {}
+      @span_children_duration = {}
       @tracked_ranges = []
       @sampler = nil
       @estimated_bytes = 0

data/lib/catpm/segment_subscribers.rb

@@ -77,7 +77,7 @@ module Catpm
           )
           Thread.current[:catpm_request_segments] = req_segments
 
-          index = req_segments.push_span(type: :controller, detail: target, started_at: start_time)
+          index = req_segments.push_span(type: :job, detail: target, started_at: start_time)
           payload[:_catpm_job_span_index] = index
           payload[:_catpm_job_owns_segments] = true
         end

data/lib/catpm/sidekiq_server_middleware.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Catpm
+  # Sidekiq server middleware that tracks native Sidekiq::Worker jobs.
+  # ActiveJob jobs are tracked via the perform.active_job subscriber instead;
+  # this middleware detects and skips them to avoid double-tracking.
+  #
+  # Automatically registered when Sidekiq is loaded and config.instrument_jobs is true.
+  class SidekiqServerMiddleware
+    def call(job_instance, job_payload, queue)
+      return yield unless Catpm.enabled? && Catpm.config.instrument_jobs
+
+      # ActiveJob wraps jobs with a 'wrapped' key — those are tracked
+      # by the perform.active_job subscriber, skip here.
+      return yield if job_payload.key?('wrapped')
+
+      target = job_payload['class'] || job_instance.class.name
+      return yield if Catpm.config.ignored?(target)
+
+      # No HTTP middleware in workers — restart flusher after fork
+      Catpm.flusher&.ensure_running!
+
+      instrumented = Collector.should_instrument?(:job, target, queue)
+      req_segments = nil
+
+      if instrumented
+        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
+        span_index = req_segments.push_span(type: :job, detail: target, started_at: start_time)
+      end
+
+      Thread.current[:catpm_job_active] = true
+      job_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      error = nil
+
+      begin
+        yield
+      rescue => e
+        error = e
+        raise
+      ensure
+        Thread.current[:catpm_job_active] = nil
+        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - job_start) * 1000.0
+
+        if req_segments
+          req_segments.pop_span(span_index)
+          req_segments.stop_sampler
+        end
+
+        queue_wait = compute_queue_wait(job_payload)
+
+        Collector.process_sidekiq_job(
+          target: target,
+          job_id: job_payload['jid'],
+          queue: queue,
+          retry_count: job_payload['retry_count'] || 0,
+          queue_wait: queue_wait,
+          duration: duration,
+          error: error,
+          req_segments: req_segments,
+          instrumented: instrumented
+        )
+
+        if instrumented
+          req_segments&.release!
+          Collector.end_instrumentation
+          Thread.current[:catpm_request_segments] = nil
+        end
+      end
+    end
+
+    private
+
+    def compute_queue_wait(job_payload)
+      enqueued_at = job_payload['enqueued_at']
+      return nil unless enqueued_at
+
+      ((Time.now.to_f - enqueued_at.to_f) * 1000.0).round(1)
+    rescue
+      nil
+    end
+  end
+end

data/lib/catpm/stack_sampler.rb

@@ -147,7 +147,7 @@ module Catpm
         if app_frame
           app_path = app_frame.path.to_s
           parent = {
-            type: 'code',
+            type: Fingerprint.app_code_type(app_path),
             detail: build_app_detail(app_frame),
             duration: duration.round(2),
             offset: offset,
@@ -233,7 +233,7 @@ module Catpm
 
         frame = node[:frame]
         seg = {
-          type: 'code',
+          type: Fingerprint.app_code_type(frame.path.to_s),
           detail: build_app_detail(frame),
           duration: duration.round(2),
           offset: ((node[:first_time] - @request_start) * MS_PER_SECOND).round(2),
@@ -329,7 +329,7 @@ module Catpm
     end
 
     def classify_path(path)
-      return 'code' if Fingerprint.app_frame?(path)
+      return Fingerprint.app_code_type(path) if Fingerprint.app_frame?(path)
 
       gem = extract_gem_name(path)
       case gem

data/lib/catpm/version.rb

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

data/lib/catpm.rb

@@ -22,9 +22,14 @@ require 'catpm/segment_subscribers'
 require 'catpm/lifecycle'
 require 'catpm/trace'
 require 'catpm/span_helpers'
+require 'catpm/sidekiq_server_middleware' if defined?(::Sidekiq)
 require 'catpm/engine'
 
 module Catpm
+  # Migration version matching the host app's Rails major.minor.
+  # Used in db/migrate/* so the gem works with Rails 7.x, 8.x, etc.
+  MIGRATION_VERSION = "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}".to_f
+
   class << self
     def configure
       yield(config)

data/lib/generators/catpm/templates/initializer.rb.tt

@@ -28,7 +28,7 @@ Catpm.configure do |config|
   # config.min_segment_duration = 5.0                   # ms — segments shorter than this are counted but not stored (0 = store all)
   # config.max_sql_length = 200                        # nil = no truncation
   # config.slow_threshold = 500                        # ms
-  # config.slow_threshold_per_kind = {}                # { http: 500, job: 5_000, custom: 1_000 }
+  # config.slow_threshold_per_kind = {}                # { http: 500, job: 1_500, custom: 1_000 }
   # config.ignored_targets = []
 
   # === Stack Sampling ===
@@ -50,7 +50,7 @@ Catpm.configure do |config|
   # config.events_max_samples_per_name = 20            # nil = unlimited
 
   # === Memory ===
-  # config.max_memory = 20  # MB — global memory budget (2% of 1GB server)
+  # config.max_memory = 20  # MB — global memory budget
 
   # === Buffering & Flushing ===
   # config.flush_interval = 30                         # seconds

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.11.0
 platform: ruby
 authors:
 - ''
@@ -65,6 +65,7 @@ files:
 - app/views/catpm/events/show.html.erb
 - app/views/catpm/samples/show.html.erb
 - app/views/catpm/shared/_page_nav.html.erb
+- app/views/catpm/shared/_segments_timeline.html.erb
 - app/views/catpm/shared/_segments_waterfall.html.erb
 - app/views/catpm/shared/not_found.html.erb
 - app/views/catpm/shared/record_not_found.html.erb
@@ -98,6 +99,7 @@ files:
 - lib/catpm/patches/net_http.rb
 - lib/catpm/request_segments.rb
 - lib/catpm/segment_subscribers.rb
+- lib/catpm/sidekiq_server_middleware.rb
 - lib/catpm/span_helpers.rb
 - lib/catpm/stack_sampler.rb
 - lib/catpm/subscribers.rb