catpm 0.3.0 → 0.5.0

data/lib/catpm/collector.rb

@@ -2,6 +2,9 @@
 
 module Catpm
   module Collector
+    SYNTHETIC_MIDDLEWARE_OFFSET_MS = 0.5
+    MIN_GAP_MS = 1.0
+
     class << self
       def process_action_controller(event)
         return unless Catpm.enabled?
@@ -65,7 +68,7 @@ module Catpm
             if ctrl_idx
               has_real_middleware = segments.any? { |s| s[:type] == 'middleware' }
               ctrl_offset = (segments[ctrl_idx][:offset] || 0.0).to_f
-              if ctrl_offset > 0.5 && !has_real_middleware
+              if ctrl_offset > SYNTHETIC_MIDDLEWARE_OFFSET_MS && !has_real_middleware
                 middleware_seg = {
                   type: 'middleware',
                   detail: 'Middleware Stack',
@@ -98,7 +101,7 @@ module Catpm
               end
               gap = ctrl_dur - child_dur
 
-              if gap > 1.0
+              if gap > MIN_GAP_MS && Catpm.config.show_untracked_segments
                 inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
               end
             end
@@ -119,7 +122,7 @@ module Catpm
 
               context[:segments] << {
                 type: 'error',
-                detail: "#{payload[:exception].first}: #{payload[:exception].last}".truncate(200),
+                detail: "#{payload[:exception].first}: #{payload[:exception].last}".truncate(Catpm.config.max_error_detail_length),
                 source: payload[:exception_object]&.backtrace&.first,
                 duration: 0,
                 offset: error_offset,
@@ -253,7 +256,7 @@ module Catpm
               end
               gap = ctrl_dur - child_dur
 
-              if gap > 1.0
+              if gap > MIN_GAP_MS && Catpm.config.show_untracked_segments
                 inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
               end
             end
@@ -274,7 +277,7 @@ module Catpm
 
               context[:segments] << {
                 type: 'error',
-                detail: "#{error.class.name}: #{error.message}".truncate(200),
+                detail: "#{error.class.name}: #{error.message}".truncate(Catpm.config.max_error_detail_length),
                 source: error.backtrace&.first,
                 duration: 0,
                 offset: error_offset,
@@ -338,7 +341,8 @@ module Catpm
         # Filling phase: always sample until endpoint has enough random samples
         endpoint_key = [kind.to_s, target, operation.to_s]
         count = random_sample_counts[endpoint_key]
-        if count < Catpm.config.max_random_samples_per_endpoint
+        max_random = Catpm.config.max_random_samples_per_endpoint
+        if max_random.nil? || count < max_random
           random_sample_counts[endpoint_key] = count + 1
           return 'random'
         end
@@ -374,22 +378,75 @@ module Catpm
           end
 
           remaining = gap - sampler_dur
-          if remaining > 1.0
-            segments << {
-              type: 'other',
-              detail: 'Untracked',
-              duration: remaining.round(2),
-              offset: (ctrl_seg[:offset] || 0.0),
-              parent_index: ctrl_idx
-            }
+          if remaining > MIN_GAP_MS
+            inject_timeline_gaps(segments, ctrl_idx, ctrl_seg, remaining)
           end
         else
+          inject_timeline_gaps(segments, ctrl_idx, ctrl_seg, gap)
+        end
+      end
+
+      # Compute actual gap intervals between tracked child segments on the timeline,
+      # then create one Untracked entry per gap. This avoids placing a single large
+      # Untracked block that overlaps with real segments.
+      def inject_timeline_gaps(segments, ctrl_idx, ctrl_seg, total_gap)
+        ctrl_offset = (ctrl_seg[:offset] || 0.0).to_f
+        ctrl_dur = (ctrl_seg[:duration] || 0.0).to_f
+        ctrl_end = ctrl_offset + ctrl_dur
+
+        # Collect [start, end] intervals of direct children that have offsets
+        intervals = []
+        segments.each_with_index do |seg, i|
+          next if i == ctrl_idx
+          next unless seg[:parent_index] == ctrl_idx
+          off = seg[:offset]
+          dur = (seg[:duration] || 0).to_f
+          next unless off
+          intervals << [off.to_f, off.to_f + dur]
+        end
+
+        # If no children have offsets, place the gap at the controller start
+        if intervals.empty?
+          segments << {
+            type: 'other', detail: 'Untracked', duration: total_gap.round(2),
+            offset: ctrl_offset, parent_index: ctrl_idx
+          }
+          return
+        end
+
+        # Sort and merge overlapping intervals
+        intervals.sort_by!(&:first)
+        merged = [intervals.first.dup]
+        intervals[1..].each do |s, e|
+          if s <= merged.last[1]
+            merged.last[1] = e if e > merged.last[1]
+          else
+            merged << [s, e]
+          end
+        end
+
+        # Find gaps between controller start, merged intervals, and controller end
+        gaps = []
+        cursor = ctrl_offset
+        merged.each do |s, e|
+          gaps << [cursor, s] if s - cursor > 0
+          cursor = [cursor, e].max
+        end
+        gaps << [cursor, ctrl_end] if ctrl_end - cursor > 0
+
+        # Distribute total_gap proportionally across timeline gaps
+        raw_gap_sum = gaps.sum { |s, e| e - s }
+        return if raw_gap_sum <= 0
+
+        gaps.each do |gs, ge|
+          raw_dur = ge - gs
+          # Scale so all Untracked segments sum to total_gap
+          dur = (raw_dur / raw_gap_sum) * total_gap
+          next if dur < MIN_GAP_MS
+
           segments << {
-            type: 'other',
-            detail: 'Untracked',
-            duration: gap.round(2),
-            offset: (ctrl_seg[:offset] || 0.0),
-            parent_index: ctrl_idx
+            type: 'other', detail: 'Untracked', duration: dur.round(2),
+            offset: gs.round(2), parent_index: ctrl_idx
           }
         end
       end

data/lib/catpm/configuration.rb

@@ -41,7 +41,17 @@ module Catpm
                   :shutdown_timeout,
                   :events_enabled,
                   :events_max_samples_per_name,
-                  :track_own_requests
+                  :track_own_requests,
+                  :stack_sample_interval,
+                  :max_stack_samples_per_request,
+                  :downsampling_thresholds,
+                  :max_error_detail_length,
+                  :max_fingerprint_app_frames,
+                  :max_fingerprint_gem_frames,
+                  :cleanup_batch_size,
+                  :caller_scan_depth,
+                  :instrument_call_tree,
+                  :show_untracked_segments
 
     def initialize
       @enabled = true
@@ -58,7 +68,7 @@ module Catpm
       @slow_threshold_per_kind = {}
       @ignored_targets = []
       @retention_period = nil # nil = keep forever (data is downsampled, not deleted)
-      @max_buffer_memory = 32.megabytes
+      @max_buffer_memory = 8.megabytes
       @flush_interval = 30 # seconds
       @flush_jitter = 5 # ±seconds
       @max_error_contexts = 5
@@ -84,6 +94,21 @@ module Catpm
       @events_enabled = false
       @events_max_samples_per_name = 20
       @track_own_requests = false
+      @stack_sample_interval = 0.005 # seconds (5ms)
+      @max_stack_samples_per_request = 200
+      @downsampling_thresholds = {
+        medium: 1.hour,
+        hourly: 24.hours,
+        daily: 1.week,
+        weekly: 90.days
+      }
+      @max_error_detail_length = 200
+      @max_fingerprint_app_frames = 5
+      @max_fingerprint_gem_frames = 3
+      @cleanup_batch_size = 1_000
+      @caller_scan_depth = 50
+      @instrument_call_tree = false
+      @show_untracked_segments = false
     end
 
     def slow_threshold_for(kind)

data/lib/catpm/event.rb

@@ -10,18 +10,24 @@ module Catpm
                   :metadata, :error_class, :error_message, :backtrace,
                   :sample_type, :context, :status
 
+    EMPTY_HASH = {}.freeze
+    private_constant :EMPTY_HASH
+
     def initialize(kind:, target:, operation: '', duration: 0.0, started_at: nil,
-                   metadata: {}, error_class: nil, error_message: nil, backtrace: nil,
-                   sample_type: nil, context: {}, status: nil)
+                   metadata: nil, error_class: nil, error_message: nil, backtrace: nil,
+                   sample_type: nil, context: nil, status: nil)
       @kind = kind.to_s
       @target = target.to_s
       @operation = (operation || '').to_s
       @duration = duration.to_f
       @started_at = started_at || Time.current
-      @metadata = metadata || {}
+      @metadata = metadata || EMPTY_HASH
       @error_class = error_class
       @error_message = error_message
-      @backtrace = backtrace
+      @backtrace = if backtrace
+        limit = Catpm.config.backtrace_lines
+        limit ? backtrace.first(limit) : backtrace
+      end
       @sample_type = sample_type
       @context = context
       @status = status
@@ -67,7 +73,7 @@ module Catpm
     end
 
     def metadata_bytes
-      return 0 if metadata.empty?
+      return 0 if metadata.nil? || metadata.empty?
 
       metadata.to_json.bytesize + REF_SIZE
     end

data/lib/catpm/fingerprint.rb

@@ -15,7 +15,7 @@ module Catpm
     def self.normalize_backtrace(backtrace)
       app_frames = backtrace
         .select { |line| app_frame?(line) }
-        .first(5)
+        .first(Catpm.config.max_fingerprint_app_frames)
         .map { |line| strip_line_number(line) }
 
       # If there are app frames, group by app code (like Sentry)
@@ -25,7 +25,7 @@ module Catpm
       # so the same bug is always one issue regardless of the caller.
       backtrace
         .reject { |line| line.include?('<internal:') }
-        .first(3)
+        .first(Catpm.config.max_fingerprint_gem_frames)
         .map { |line| strip_line_number(line) }
         .join("\n")
     end

data/lib/catpm/flusher.rb

@@ -2,6 +2,8 @@
 
 module Catpm
   class Flusher
+    ERROR_LOG_BACKTRACE_LINES = 5
+
     attr_reader :running
 
     def initialize(buffer:, interval: nil, jitter: nil)
@@ -104,7 +106,7 @@ module Catpm
       events&.each { |ev| @buffer.push(ev) }
       @circuit.record_failure
       Catpm.config.error_handler.call(e)
-      Rails.logger.error("[catpm] flush error: #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
+      Rails.logger.error("[catpm] flush error: #{e.class}: #{e.message}\n#{e.backtrace&.first(ERROR_LOG_BACKTRACE_LINES)&.join("\n")}")
     end
 
     def reset!
@@ -190,7 +192,8 @@ module Catpm
           error[:last_occurred_at] = [ error[:last_occurred_at], event.started_at ].max
           error[:occurrence_times] << event.started_at
 
-          if error[:new_contexts].size < Catpm.config.max_error_contexts
+          max_ctx = Catpm.config.max_error_contexts
+          if max_ctx.nil? || error[:new_contexts].size < max_ctx
             error[:new_contexts] << build_error_context(event)
           end
         end
@@ -225,34 +228,68 @@ module Catpm
 
 
     def rotate_samples(samples)
+      return samples if samples.empty?
+
+      # Pre-fetch counts for all endpoints and types in bulk
+      endpoint_keys = samples.map { |s| s[:bucket_key][0..2] }.uniq
+      error_fps = samples.filter_map { |s| s[:error_fingerprint] }.uniq
+
+      # Build counts cache: { [kind, target, op, type] => count }
+      counts_cache = {}
+      if endpoint_keys.any?
+        Catpm::Sample.joins(:bucket)
+          .where(catpm_buckets: { kind: endpoint_keys.map(&:first), target: endpoint_keys.map { |k| k[1] }, operation: endpoint_keys.map { |k| k[2] } })
+          .where(sample_type: %w[random slow])
+          .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation', 'catpm_samples.sample_type')
+          .count
+          .each { |(kind, target, op, type), cnt| counts_cache[[kind, target, op, type]] = cnt }
+      end
+
+      error_counts = {}
+      if error_fps.any?
+        Catpm::Sample.where(sample_type: 'error', error_fingerprint: error_fps)
+          .group(:error_fingerprint).count
+          .each { |fp, cnt| error_counts[fp] = cnt }
+      end
+
       samples.each do |sample|
-        kind, target, operation = sample[:bucket_key][0], sample[:bucket_key][1], sample[:bucket_key][2]
-        endpoint_samples = Catpm::Sample
-          .joins(:bucket)
-          .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+        kind, target, operation = sample[:bucket_key][0..2]
 
         case sample[:sample_type]
         when 'random'
-          existing = endpoint_samples.where(sample_type: 'random')
-          if existing.count >= Catpm.config.max_random_samples_per_endpoint
-            existing.order(recorded_at: :asc).first.destroy
+          max_random = Catpm.config.max_random_samples_per_endpoint
+          if max_random
+            cache_key = [kind, target, operation, 'random']
+            if (counts_cache[cache_key] || 0) >= max_random
+              oldest = Catpm::Sample.joins(:bucket)
+                .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+                .where(sample_type: 'random').order(recorded_at: :asc).first
+              oldest&.destroy
+            end
           end
         when 'slow'
-          existing = endpoint_samples.where(sample_type: 'slow')
-          if existing.count >= Catpm.config.max_slow_samples_per_endpoint
-            weakest = existing.order(duration: :asc).first
-            if sample[:duration] > weakest.duration
-              weakest.destroy
-            else
-              sample[:_skip] = true
+          max_slow = Catpm.config.max_slow_samples_per_endpoint
+          if max_slow
+            cache_key = [kind, target, operation, 'slow']
+            if (counts_cache[cache_key] || 0) >= max_slow
+              weakest = Catpm::Sample.joins(:bucket)
+                .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+                .where(sample_type: 'slow').order(duration: :asc).first
+              if weakest && sample[:duration] > weakest.duration
+                weakest.destroy
+              else
+                sample[:_skip] = true
+              end
             end
           end
         when 'error'
-          fp = sample[:error_fingerprint]
-          if fp
-            existing = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
-            if existing.count >= Catpm.config.max_error_samples_per_fingerprint
-              existing.order(recorded_at: :asc).first.destroy
+          max_err = Catpm.config.max_error_samples_per_fingerprint
+          if max_err
+            fp = sample[:error_fingerprint]
+            if fp && (error_counts[fp] || 0) >= max_err
+              oldest = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
+                .order(recorded_at: :asc).first
+              oldest&.destroy
             end
           end
         end
@@ -267,11 +304,7 @@ module Catpm
         occurred_at: event.started_at.iso8601,
         kind: event.kind,
         operation: event_context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
-        backtrace: begin
-          bt = event.backtrace || []
-          limit = Catpm.config.backtrace_lines
-          limit ? bt.first(limit) : bt
-        end,
+        backtrace: event.backtrace || [],
         duration: event.duration,
         status: event.status
       }
@@ -314,7 +347,7 @@ module Catpm
 
         max = Catpm.config.events_max_samples_per_name
         if event.payload.any?
-          if sample_counts[event.name] < max
+          if max.nil? || sample_counts[event.name] < max
             samples << { name: event.name, payload: event.payload, recorded_at: event.recorded_at }
             sample_counts[event.name] += 1
           elsif rand(Catpm.config.random_sample_rate) == 0
@@ -336,101 +369,103 @@ module Catpm
 
     def downsample_buckets
       bucket_sizes = Catpm.config.bucket_sizes
+      thresholds = Catpm.config.downsampling_thresholds
       adapter = Catpm::Adapter.current
 
       # Phase 1: Merge 1-minute buckets older than 1 hour into 5-minute buckets
       downsample_tier(
         target_interval: bucket_sizes[:medium],
-        age_threshold: 1.hour,
+        age_threshold: thresholds[:medium],
         adapter: adapter
       )
 
       # Phase 2: Merge 5-minute buckets older than 24 hours into 1-hour buckets
       downsample_tier(
         target_interval: bucket_sizes[:hourly],
-        age_threshold: 24.hours,
+        age_threshold: thresholds[:hourly],
         adapter: adapter
       )
 
       # Phase 3: Merge 1-hour buckets older than 1 week into 1-day buckets
       downsample_tier(
         target_interval: bucket_sizes[:daily],
-        age_threshold: 1.week,
+        age_threshold: thresholds[:daily],
         adapter: adapter
       )
 
       # Phase 4: Merge 1-day buckets older than 3 months into 1-week buckets
       downsample_tier(
         target_interval: bucket_sizes[:weekly],
-        age_threshold: 90.days,
+        age_threshold: thresholds[:weekly],
         adapter: adapter
       )
 
       # Event buckets: same downsampling tiers
-      downsample_event_tier(target_interval: bucket_sizes[:medium], age_threshold: 1.hour, adapter: adapter)
-      downsample_event_tier(target_interval: bucket_sizes[:hourly], age_threshold: 24.hours, adapter: adapter)
-      downsample_event_tier(target_interval: bucket_sizes[:daily], age_threshold: 1.week, adapter: adapter)
-      downsample_event_tier(target_interval: bucket_sizes[:weekly], age_threshold: 90.days, adapter: adapter)
+      downsample_event_tier(target_interval: bucket_sizes[:medium], age_threshold: thresholds[:medium], adapter: adapter)
+      downsample_event_tier(target_interval: bucket_sizes[:hourly], age_threshold: thresholds[:hourly], adapter: adapter)
+      downsample_event_tier(target_interval: bucket_sizes[:daily], age_threshold: thresholds[:daily], adapter: adapter)
+      downsample_event_tier(target_interval: bucket_sizes[:weekly], age_threshold: thresholds[:weekly], adapter: adapter)
     end
 
     def downsample_tier(target_interval:, age_threshold:, adapter:)
       cutoff = age_threshold.ago
       target_seconds = target_interval.to_i
 
-      # Find all buckets older than cutoff
-      source_buckets = Catpm::Bucket.where(bucket_start: ...cutoff).to_a
-      return if source_buckets.empty?
-
-      # Group by (kind, target, operation) + target-aligned bucket_start
-      groups = source_buckets.group_by do |bucket|
-        epoch = bucket.bucket_start.to_i
-        aligned_epoch = epoch - (epoch % target_seconds)
-        aligned_start = Time.at(aligned_epoch).utc
-
-        [bucket.kind, bucket.target, bucket.operation, aligned_start]
-      end
-
-      groups.each do |(kind, target, operation, aligned_start), buckets|
-        # Skip if only one bucket already at the target alignment
-        next if buckets.size == 1 && buckets.first.bucket_start.to_i % target_seconds == 0
+      # Process in batches to avoid loading all old buckets into memory
+      Catpm::Bucket.where(bucket_start: ...cutoff)
+        .select(:id, :kind, :target, :operation, :bucket_start)
+        .group_by { |b| [b.kind, b.target, b.operation] }
+        .each do |(_kind, _target, _operation), endpoint_buckets|
+          groups = endpoint_buckets.group_by do |bucket|
+            epoch = bucket.bucket_start.to_i
+            aligned_epoch = epoch - (epoch % target_seconds)
+            Time.at(aligned_epoch).utc
+          end
 
-        merged = {
-          kind: kind,
-          target: target,
-          operation: operation,
-          bucket_start: aligned_start,
-          count: buckets.sum(&:count),
-          success_count: buckets.sum(&:success_count),
-          failure_count: buckets.sum(&:failure_count),
-          duration_sum: buckets.sum(&:duration_sum),
-          duration_max: buckets.map(&:duration_max).max,
-          duration_min: buckets.map(&:duration_min).min,
-          metadata_sum: merge_bucket_metadata(buckets, adapter),
-          p95_digest: merge_bucket_digests(buckets)
-        }
-
-        source_ids = buckets.map(&:id)
-        survivor = buckets.first
-
-        # Reassign all samples to the survivor bucket
-        Catpm::Sample.where(bucket_id: source_ids).update_all(bucket_id: survivor.id)
-
-        # Delete non-survivor source buckets (now sample-free)
-        Catpm::Bucket.where(id: source_ids - [survivor.id]).delete_all
-
-        # Overwrite survivor with merged data
-        survivor.update!(
-          bucket_start: aligned_start,
-          count: merged[:count],
-          success_count: merged[:success_count],
-          failure_count: merged[:failure_count],
-          duration_sum: merged[:duration_sum],
-          duration_max: merged[:duration_max],
-          duration_min: merged[:duration_min],
-          metadata_sum: merged[:metadata_sum],
-          p95_digest: merged[:p95_digest]
-        )
-      end
+          groups.each do |aligned_start, stub_buckets|
+            next if stub_buckets.size == 1 && stub_buckets.first.bucket_start.to_i % target_seconds == 0
+
+            # Load full records only for groups that need merging
+            bucket_ids = stub_buckets.map(&:id)
+            buckets = Catpm::Bucket.where(id: bucket_ids).to_a
+
+            merged = {
+              kind: buckets.first.kind,
+              target: buckets.first.target,
+              operation: buckets.first.operation,
+              bucket_start: aligned_start,
+              count: buckets.sum(&:count),
+              success_count: buckets.sum(&:success_count),
+              failure_count: buckets.sum(&:failure_count),
+              duration_sum: buckets.sum(&:duration_sum),
+              duration_max: buckets.map(&:duration_max).max,
+              duration_min: buckets.map(&:duration_min).min,
+              metadata_sum: merge_bucket_metadata(buckets, adapter),
+              p95_digest: merge_bucket_digests(buckets)
+            }
+
+            survivor = buckets.first
+
+            # Reassign all samples to the survivor bucket
+            Catpm::Sample.where(bucket_id: bucket_ids).update_all(bucket_id: survivor.id)
+
+            # Delete non-survivor source buckets (now sample-free)
+            Catpm::Bucket.where(id: bucket_ids - [survivor.id]).delete_all
+
+            # Overwrite survivor with merged data
+            survivor.update!(
+              bucket_start: aligned_start,
+              count: merged[:count],
+              success_count: merged[:success_count],
+              failure_count: merged[:failure_count],
+              duration_sum: merged[:duration_sum],
+              duration_max: merged[:duration_max],
+              duration_min: merged[:duration_min],
+              metadata_sum: merged[:metadata_sum],
+              p95_digest: merged[:p95_digest]
+            )
+          end
+        end
     end
 
     def downsample_event_tier(target_interval:, age_threshold:, adapter:)
@@ -474,7 +509,7 @@ module Catpm
 
     def cleanup_expired_data
       cutoff = Catpm.config.retention_period.ago
-      batch_size = 1_000
+      batch_size = Catpm.config.cleanup_batch_size
 
       [ Catpm::Bucket, Catpm::Sample ].each do |model|
         time_column = model == Catpm::Sample ? :recorded_at : :bucket_start

data/lib/catpm/middleware.rb

@@ -21,6 +21,12 @@ module Catpm
         )
         env['catpm.segments'] = req_segments
         Thread.current[:catpm_request_segments] = req_segments
+
+        if Catpm.config.instrument_call_tree
+          call_tracer = CallTracer.new(request_segments: req_segments)
+          call_tracer.start
+          env['catpm.call_tracer'] = call_tracer
+        end
       end
 
       @app.call(env)
@@ -29,6 +35,7 @@ module Catpm
       raise
     ensure
       if Catpm.config.instrument_segments
+        env['catpm.call_tracer']&.stop
         req_segments&.stop_sampler
         Thread.current[:catpm_request_segments] = nil
       end

data/lib/catpm/request_segments.rb

@@ -36,7 +36,7 @@ module Catpm
         @tracked_ranges << [started_at, started_at + duration / 1000.0]
       end
 
-      if @segments.size < @max_segments
+      if @max_segments.nil? || @segments.size < @max_segments
         @segments << segment
       else
         @overflow = true
@@ -54,7 +54,7 @@ module Catpm
       segment[:offset] = offset if offset
       segment[:parent_index] = @span_stack.last if @span_stack.any?
 
-      return nil if @segments.size >= @max_segments
+      return nil if @max_segments && @segments.size >= @max_segments
 
       index = @segments.size
       @segments << segment

data/lib/catpm/segment_subscribers.rb

@@ -2,6 +2,8 @@
 
 module Catpm
   module SegmentSubscribers
+    MIN_INSTANTIATION_DURATION_MS = 0.1
+    CALLER_OFFSET = 4 # frames to skip to reach user code from this call site
     # Subscriber with start/finish callbacks so all segments (SQL, views, etc.)
     # fired during a controller action are automatically nested under the controller span.
     class ControllerSpanSubscriber
@@ -146,7 +148,7 @@ module Catpm
         return unless req_segments
 
         duration = event.duration
-        return if duration < 0.1 # skip trivial instantiations
+        return if duration < MIN_INSTANTIATION_DURATION_MS # skip trivial instantiations
 
         payload = event.payload
         record_count = payload[:record_count] || 0
@@ -171,6 +173,8 @@ module Catpm
 
         duration = event.duration
         sql = payload[:sql].to_s
+        max_len = Catpm.config.max_sql_length
+        sql = sql.truncate(max_len) if max_len && sql.length > max_len
         source = duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
 
         req_segments.add(
@@ -228,7 +232,7 @@ module Catpm
       end
 
       def extract_source_location
-        locations = caller_locations(4, 50)
+        locations = caller_locations(CALLER_OFFSET, Catpm.config.caller_scan_depth)
         locations&.each do |loc|
           path = loc.path.to_s
           if Fingerprint.app_frame?(path)