opentrace 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbe3de5afdb5f92afcef49d368b8f8b3714ca17fe453b168066f53a5b0e5e1ba
-  data.tar.gz: 8f749e943951c939e7daa8f93a454bb0c89646bc295c0550c680064ebf38db16
+  metadata.gz: fd043296872a0f5241acc4f8331bc2d6c6f7e39628e0501fc6e0480af7c423f9
+  data.tar.gz: b37915c9ed52898d6607a668c264c573f8d2012d937ec4053712ff2c65fb741e
 SHA512:
-  metadata.gz: e3ecb7c4b649951f64e1090bb7ea06da69cb603dcd44534c9a5e71d76eb697239fddf2267cd2a5e0cff2aa1bf86dc78be6733be754df8e5c6a435967d90809a8
-  data.tar.gz: 3625d9de1cd2dda011f69283b34a17964450cda3c44c0f19431fb450e2a24328f1c260a12ea9929331a54866ac90afd07addd65e16cb2eee9e42a939807f3a69
+  metadata.gz: a9567eefab80204781b112f43f915a755ad55327eef2255b7b9c655da9eb36e4eed55c6617e1711d00bbd74ec9dd1f88332b0f0c0c4e2e0562e75a1fdcb8a9fe
+  data.tar.gz: 11bf43482a27798a4bcf20c7cb700a565692d2b863d3011feb403df97e039b2b75cd35e0e53f12d7b17a107b7d07ef1959c0539d9507397376bb8901afcb9346

data/lib/opentrace/client.rb

@@ -11,7 +11,6 @@ module OpenTrace
   class Client
     MAX_QUEUE_SIZE = 1000
     PAYLOAD_MAX_BYTES = 262_144 # 256 KB (default; use config.max_payload_bytes to override)
-    POLL_INTERVAL = 0.05 # 50ms
     MAX_RATE_LIMIT_BACKOFF = 60 # Cap Retry-After at 60 seconds
     API_VERSION = 1
 
@@ -95,12 +94,13 @@ module OpenTrace
     end
 
     def reset_after_fork!
-      # After fork, the old thread/queue/mutex from the parent are dead.
+      # After fork, the old thread/queue/mutex/connection from the parent are dead.
       # Re-create everything cleanly in the child process.
       @pid    = Process.pid
       @queue  = Thread::Queue.new
       @mutex  = Mutex.new
       @thread = nil
+      @http   = nil # Parent's connection is unusable after fork
       @circuit_breaker.reset!
       @rate_limit_until = nil
       @auth_suspended = false
@@ -143,6 +143,8 @@ module OpenTrace
       end
     rescue Exception # rubocop:disable Lint/RescueException
       # Swallow all errors including thread kill
+    ensure
+      close_http
     end
 
     def rate_limited?
@@ -188,16 +190,14 @@ module OpenTrace
     end
 
     def pop_with_timeout(timeout)
-      deadline = Time.now + [timeout, 0].max
-      loop do
-        begin
-          return @queue.pop(true)
-        rescue ThreadError
-          return nil if Time.now >= deadline || @queue.closed?
-          sleep(POLL_INTERVAL)
-        end
+      if timeout <= 0
+        # Deadline already passed — still try a non-blocking pop in case
+        # items arrived while we were busy (e.g. during version check).
+        @queue.pop(true)
+      else
+        @queue.pop(timeout: timeout)
       end
-    rescue ClosedQueueError
+    rescue ThreadError, ClosedQueueError
       nil
     end
 
@@ -330,7 +330,6 @@ module OpenTrace
     end
 
     def http_post(json, batch_id: nil)
-      http = build_http(@uri)
       request = Net::HTTP::Post.new(@uri.request_uri)
       request["Authorization"] = "Bearer #{@config.api_key}"
       request["Content-Type"]  = "application/json"
@@ -345,7 +344,11 @@ module OpenTrace
         request.body = json
       end
 
-      http.request(request)
+      persistent_http.request(request)
+    rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Net::OpenTimeout => _e
+      # Connection went stale — reset and retry once
+      close_http
+      persistent_http.request(request)
     end
 
     def retryable_response?(response)
@@ -359,13 +362,27 @@ module OpenTrace
       delay + jitter
     end
 
-    def build_http(uri)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = @config.timeout
-      http.read_timeout = @config.timeout
-      http.write_timeout = @config.timeout
-      http
+    # Returns a persistent Net::HTTP connection, creating one if needed.
+    # Only called from the dispatch thread — no synchronization needed.
+    def persistent_http
+      return @http if @http&.started?
+
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @http.use_ssl = (@uri.scheme == "https")
+      @http.open_timeout = @config.timeout
+      @http.read_timeout = @config.timeout
+      @http.write_timeout = @config.timeout
+      @http.keep_alive_timeout = 30
+      @http.start
+      @http
+    end
+
+    def close_http
+      @http&.finish
+    rescue IOError
+      # Already closed
+    ensure
+      @http = nil
     end
 
     def gzip_compress(string)
@@ -421,13 +438,20 @@ module OpenTrace
       end
 
       @compatibility_checked = true
-    rescue StandardError
-      # Server might not support /api/version yet — that's fine
+    rescue Exception # rubocop:disable Lint/RescueException
+      # Server might not support /api/version yet — that's fine.
+      # Broad rescue: this is best-effort and must never kill the dispatch loop.
       @compatibility_checked = true
     end
 
+    # One-shot GET for version check. Uses a throwaway connection
+    # so a failure doesn't poison the persistent connection.
     def http_get(uri)
-      http = build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @config.timeout
+      http.read_timeout = @config.timeout
+      http.write_timeout = @config.timeout
       request = Net::HTTP::Get.new(uri.request_uri)
       request["User-Agent"] = "opentrace-ruby/#{OpenTrace::VERSION}"
       request["Authorization"] = "Bearer #{@config.api_key}"

data/lib/opentrace/config.rb

@@ -20,7 +20,9 @@ module OpenTrace
                   :request_summary, :timeline, :timeline_max_events,
                   :memory_tracking, :http_tracking,
                   :max_payload_bytes,
-                  :trace_propagation
+                  :trace_propagation,
+                  :log_forwarding, :view_tracking, :cache_tracking,
+                  :deprecation_tracking, :detailed_request_log
 
     def initialize
       @endpoint    = nil
@@ -30,7 +32,7 @@ module OpenTrace
       @timeout     = 1.0
       @enabled     = true
       @context     = nil    # nil | Hash | Proc
-      @min_level   = :debug # send everything by default
+      @min_level   = :info
       @allowed_levels = nil  # nil = use min_level threshold (backward compatible)
       @hostname       = nil
       @pid            = nil
@@ -46,7 +48,7 @@ module OpenTrace
       @on_drop        = nil # ->(count, reason) { ... }
       @compression    = true
       @compression_threshold = 1024 # only compress payloads > 1KB
-      @sql_logging    = true
+      @sql_logging    = false
       @sql_duration_threshold_ms = 0.0
       @ignore_paths   = []
       @pool_monitoring = false
@@ -54,12 +56,17 @@ module OpenTrace
       @queue_monitoring = false
       @queue_monitoring_interval = 60
       @request_summary = true
-      @timeline = true
+      @timeline = false
       @timeline_max_events = 200
       @memory_tracking = false
       @http_tracking = false
       @max_payload_bytes = 262_144 # 256 KB
       @trace_propagation = true
+      @log_forwarding = false
+      @view_tracking = false
+      @cache_tracking = false
+      @deprecation_tracking = false
+      @detailed_request_log = false
     end
 
     def valid?

data/lib/opentrace/middleware.rb

@@ -10,6 +10,9 @@ module OpenTrace
     end
 
     def call(env)
+      # When OpenTrace is disabled, pass through with zero overhead
+      return @app.call(env) unless OpenTrace.enabled?
+
       request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
       OpenTrace.current_request_id = request_id
       Fiber[:opentrace_sql_count] = 0
@@ -25,15 +28,18 @@ module OpenTrace
         Fiber[:opentrace_parent_span_id] = parent_span_id
       end
 
-      # Create RequestCollector for accumulate-and-summarize pattern
-      if OpenTrace.enabled? && OpenTrace.config.request_summary
-        collector = OpenTrace::RequestCollector.new(
-          max_timeline: OpenTrace.config.timeline_max_events
-        )
+      # Create RequestCollector only when features that need it are enabled
+      cfg = OpenTrace.config
+      needs_collector = cfg.request_summary &&
+        (cfg.view_tracking || cfg.cache_tracking || cfg.http_tracking ||
+         cfg.timeline || cfg.memory_tracking)
+
+      if needs_collector
+        max_timeline = cfg.timeline ? cfg.timeline_max_events : 0
+        collector = OpenTrace::RequestCollector.new(max_timeline: max_timeline)
         Fiber[:opentrace_collector] = collector
 
-        # Memory snapshot before request (opt-in)
-        if OpenTrace.config.memory_tracking
+        if cfg.memory_tracking
           collector.memory_before = current_rss_mb
         end
       end

data/lib/opentrace/rails.rb

@@ -13,140 +13,111 @@ if defined?(::Rails::Railtie)
       config.after_initialize do |app|
         next unless OpenTrace.enabled?
 
-        if Rails.logger.respond_to?(:broadcast_to)
-          # Rails 7.1+: register as a broadcast target (non-invasive)
-          Rails.logger.broadcast_to(OpenTrace::LogForwarder.new)
-        else
-          # Pre-7.1 fallback: wrap the logger directly
-          if app.config.logger
-            app.config.logger = OpenTrace::Logger.new(app.config.logger)
-            Rails.logger = app.config.logger
-          elsif Rails.logger
-            Rails.logger = OpenTrace::Logger.new(Rails.logger)
+        # Log forwarding (opt-in) — registers LogForwarder/Logger wrapper
+        if OpenTrace.config.log_forwarding
+          if Rails.logger.respond_to?(:broadcast_to)
+            Rails.logger.broadcast_to(OpenTrace::LogForwarder.new)
+          else
+            if app.config.logger
+              app.config.logger = OpenTrace::Logger.new(app.config.logger)
+              Rails.logger = app.config.logger
+            elsif Rails.logger
+              Rails.logger = OpenTrace::Logger.new(Rails.logger)
+            end
           end
         end
 
-        # Subscribe to controller request notifications
-        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
-          event = ActiveSupport::Notifications::Event.new(*args)
-          forward_request_log(event)
+        # Subscribe to controller request notifications — always on
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |name, started, finished, id, payload|
+          forward_request_log(name, started, finished, id, payload)
         rescue StandardError
           # Swallow - never affect the host app
         end
 
-        # Subscribe to SQL query notifications (also increments N+1 counter and feeds collector)
-        if OpenTrace.config.sql_logging
-          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-            # Skip Event allocation when outside a request and below threshold
-            sql_count = Fiber[:opentrace_sql_count]
-            collector = Fiber[:opentrace_collector]
-            needs_forward = OpenTrace.config.sql_duration_threshold_ms <= 0
-
-            next unless sql_count || collector || needs_forward
+        # SQL subscriber — lightweight counter + optional forwarding
+        sql_logging = OpenTrace.config.sql_logging
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |name, started, finished, id, payload|
+          sql_count = Fiber[:opentrace_sql_count]
+          collector = Fiber[:opentrace_collector]
 
-            event = ActiveSupport::Notifications::Event.new(*args)
+          if sql_count || collector || sql_logging
+            duration_ms = (finished && started) ? (finished - started) * 1000.0 : 0.0
 
-            # Increment per-request SQL counter (Fiber-local, zero-cost)
+            # Increment per-request SQL counter (~1-5μs)
             if sql_count
               Fiber[:opentrace_sql_count] = sql_count + 1
-              Fiber[:opentrace_sql_total_ms] = (Fiber[:opentrace_sql_total_ms] || 0.0) + (event.duration || 0.0)
+              Fiber[:opentrace_sql_total_ms] = (Fiber[:opentrace_sql_total_ms] || 0.0) + duration_ms
             end
 
-            # Feed RequestCollector for timeline & summary
+            # Feed RequestCollector for summary (no table extraction on hot path)
             if collector
-              payload = event.payload
               unless payload[:name] == "SCHEMA"
-                table = nil
-                if payload[:sql] =~ /\b(?:FROM|INTO|UPDATE|JOIN)\s+[`"]?(\w+)[`"]?/i
-                  table = $1
-                end
-                collector.record_sql(name: payload[:name], duration_ms: event.duration || 0.0, table: table)
+                collector.record_sql(name: payload[:name], duration_ms: duration_ms)
               end
             end
 
-            forward_sql_log(event)
-          rescue StandardError
-            # Swallow
-          end
-        else
-          # Even when sql_logging is off, still count queries for N+1 detection and feed collector
-          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-            sql_count = Fiber[:opentrace_sql_count]
-            collector = Fiber[:opentrace_collector]
-            next unless sql_count || collector
-
-            event = ActiveSupport::Notifications::Event.new(*args)
-
-            if sql_count
-              Fiber[:opentrace_sql_count] = sql_count + 1
-              Fiber[:opentrace_sql_total_ms] = (Fiber[:opentrace_sql_total_ms] || 0.0) + (event.duration || 0.0)
-            end
-
-            # Feed RequestCollector for timeline & summary
-            if collector
-              payload = event.payload
-              unless payload[:name] == "SCHEMA"
-                table = nil
-                if payload[:sql] =~ /\b(?:FROM|INTO|UPDATE|JOIN)\s+[`"]?(\w+)[`"]?/i
-                  table = $1
-                end
-                collector.record_sql(name: payload[:name], duration_ms: event.duration || 0.0, table: table)
-              end
+            # Forward individual SQL log (opt-in)
+            if sql_logging
+              forward_sql_log(payload, duration_ms)
             end
-          rescue StandardError
-            # Swallow
           end
-        end
-
-        # Subscribe to ActiveJob notifications
-        ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
-          event = ActiveSupport::Notifications::Event.new(*args)
-          forward_job_log(event)
         rescue StandardError
           # Swallow
         end
 
-        # Subscribe to deprecation warnings
-        ActiveSupport::Notifications.subscribe("deprecation.rails") do |*args|
+        # Subscribe to ActiveJob notifications — always on
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
           event = ActiveSupport::Notifications::Event.new(*args)
-          forward_deprecation_log(event)
+          forward_job_log(event)
         rescue StandardError
           # Swallow
         end
 
-        # View render tracking (only records when RequestCollector exists)
-        %w[render_template.action_view render_partial.action_view].each do |event_name|
-          ActiveSupport::Notifications.subscribe(event_name) do |*args|
-            collector = Fiber[:opentrace_collector]
-            next unless collector
-
-            event = ActiveSupport::Notifications::Event.new(*args)
-            template = event.payload[:identifier]
-            # Shorten: /Users/deploy/app/views/orders/show.html.erb → orders/show.html.erb
-            template = template.split("views/").last if template&.include?("views/")
-
-            collector.record_view(template: template, duration_ms: event.duration || 0.0)
+        # Deprecation warnings (opt-in)
+        if OpenTrace.config.deprecation_tracking
+          ActiveSupport::Notifications.subscribe("deprecation.rails") do |_name, _started, _finished, _id, payload|
+            forward_deprecation_log(payload)
           rescue StandardError
             # Swallow
           end
         end
 
-        # Cache operation tracking (only records when RequestCollector exists)
-        %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
-          ActiveSupport::Notifications.subscribe(event_name) do |*args|
-            collector = Fiber[:opentrace_collector]
-            next unless collector
+        # View render tracking (opt-in)
+        if OpenTrace.config.view_tracking
+          %w[render_template.action_view render_partial.action_view].each do |event_name|
+            ActiveSupport::Notifications.subscribe(event_name) do |_name, started, finished, _id, payload|
+              collector = Fiber[:opentrace_collector]
+              next unless collector
 
-            event = ActiveSupport::Notifications::Event.new(*args)
-            action = event_name.split(".").first.sub("cache_", "").to_sym # :read, :write, :delete
+              duration_ms = (finished && started) ? (finished - started) * 1000.0 : 0.0
+              template = payload[:identifier]
+              template = template.split("views/").last if template&.include?("views/")
 
-            collector.record_cache(
-              action: action,
-              hit: event.payload[:hit],
-              duration_ms: event.duration || 0.0
-            )
-          rescue StandardError
-            # Swallow
+              collector.record_view(template: template, duration_ms: duration_ms)
+            rescue StandardError
+              # Swallow
+            end
+          end
+        end
+
+        # Cache operation tracking (opt-in)
+        if OpenTrace.config.cache_tracking
+          %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
+            ActiveSupport::Notifications.subscribe(event_name) do |_name, started, finished, _id, payload|
+              collector = Fiber[:opentrace_collector]
+              next unless collector
+
+              duration_ms = (finished && started) ? (finished - started) * 1000.0 : 0.0
+              action = event_name.split(".").first.sub("cache_", "").to_sym
+
+              collector.record_cache(
+                action: action,
+                hit: payload[:hit],
+                duration_ms: duration_ms
+              )
+            rescue StandardError
+              # Swallow
+            end
           end
         end
 
@@ -177,20 +148,21 @@ if defined?(::Rails::Railtie)
       class << self
         private
 
-        def forward_request_log(event)
+        def forward_request_log(_name, started, finished, _id, payload)
           return unless OpenTrace.enabled?
-
-          payload = event.payload
           return if ignored_path?(payload[:path])
+
+          duration_ms = (finished && started) ? (finished - started) * 1000.0 : 0.0
+
           metadata = {
             request_id: payload[:headers]&.env&.dig("action_dispatch.request_id")
           }.compact
 
-          # Attempt to capture current user ID if available
-          user_id = extract_user_id(payload)
+          # User ID from cached context only (never calls controller.current_user)
+          user_id = extract_user_id
           metadata[:user_id] = user_id if user_id
 
-          # Exception auto-capture with fingerprinting
+          # Exception auto-capture with fingerprinting (always on)
           if payload[:exception]
             metadata[:exception_class]   = payload[:exception][0]
             metadata[:exception_message] = truncate(payload[:exception][1], 500)
@@ -203,11 +175,11 @@ if defined?(::Rails::Railtie)
               payload[:exception][0], cleaned)
           end
 
-          # Filtered request params
-          extract_params(payload, metadata)
-
-          # Request headers
-          extract_request_headers(payload, metadata)
+          # Detailed request info (opt-in)
+          if OpenTrace.config.detailed_request_log
+            extract_params(payload, metadata)
+            extract_request_headers(payload, metadata)
+          end
 
           # Build structured request_summary from collector (or fall back to Fiber-locals)
           request_summary = nil
@@ -220,7 +192,7 @@ if defined?(::Rails::Railtie)
               method: payload[:method],
               path: payload[:path],
               status: payload[:status],
-              duration_ms: event.duration&.round(1),
+              duration_ms: duration_ms.round(1),
               sql_count: summary[:sql_query_count],
               sql_total_ms: summary[:sql_total_ms],
               sql_slowest_ms: summary[:sql_slowest_ms],
@@ -245,11 +217,10 @@ if defined?(::Rails::Railtie)
             }.compact
 
             # Compute time breakdown
-            total = event.duration || 0.0
-            if total > 0
-              sql_pct = [((collector.sql_total_ms / total) * 100).round(1), 100.0].min
-              view_pct = [((collector.view_total_ms / total) * 100).round(1), 100.0].min
-              http_pct = collector.http_count > 0 ? [((collector.http_total_ms / total) * 100).round(1), 100.0].min : 0.0
+            if duration_ms > 0
+              sql_pct = [((collector.sql_total_ms / duration_ms) * 100).round(1), 100.0].min
+              view_pct = [((collector.view_total_ms / duration_ms) * 100).round(1), 100.0].min
+              http_pct = collector.http_count > 0 ? [((collector.http_total_ms / duration_ms) * 100).round(1), 100.0].min : 0.0
               other_pct = [100 - sql_pct - view_pct - http_pct, 0].max.round(1)
               request_summary[:time_breakdown] = {
                 sql_pct: sql_pct,
@@ -265,7 +236,7 @@ if defined?(::Rails::Railtie)
             metadata[:method] = payload[:method]
             metadata[:path] = payload[:path]
             metadata[:status] = payload[:status]
-            metadata[:duration_ms] = event.duration&.round(1)
+            metadata[:duration_ms] = duration_ms.round(1)
             metadata[:sql_query_count] = Fiber[:opentrace_sql_count]
             metadata[:sql_total_ms] = Fiber[:opentrace_sql_total_ms]&.round(1)
             metadata[:n_plus_one_warning] = true if Fiber[:opentrace_sql_count] > 20
@@ -276,7 +247,7 @@ if defined?(::Rails::Railtie)
             metadata[:method] = payload[:method]
             metadata[:path] = payload[:path]
             metadata[:status] = payload[:status]
-            metadata[:duration_ms] = event.duration&.round(1)
+            metadata[:duration_ms] = duration_ms.round(1)
           end
 
           level = if payload[:exception]
@@ -288,7 +259,7 @@ if defined?(::Rails::Railtie)
                   else
                     "INFO"
                   end
-          message = "#{payload[:method]} #{payload[:path]} #{payload[:status]} #{event.duration&.round(1)}ms"
+          message = "#{payload[:method]} #{payload[:path]} #{payload[:status]} #{duration_ms.round(1)}ms"
 
           OpenTrace.log(level, message, metadata, request_summary: request_summary)
         rescue StandardError
@@ -356,11 +327,10 @@ if defined?(::Rails::Railtie)
           # Swallow
         end
 
-        def forward_sql_log(event)
+        def forward_sql_log(payload, duration_ms)
           return unless OpenTrace.enabled?
 
-          payload = event.payload
-          duration = event.duration&.round(2)
+          duration = duration_ms&.round(2)
           threshold = OpenTrace.config.sql_duration_threshold_ms
 
           # Skip if below threshold
@@ -389,10 +359,9 @@ if defined?(::Rails::Railtie)
           # Swallow
         end
 
-        def forward_deprecation_log(event)
+        def forward_deprecation_log(payload)
           return unless OpenTrace.enabled?
 
-          payload = event.payload
           message = payload[:message].to_s
           callsite = payload[:callstack]&.first&.to_s
 
@@ -423,19 +392,9 @@ if defined?(::Rails::Railtie)
           # Swallow
         end
 
-        def extract_user_id(payload)
-          # Prefer user_id from cached request context (avoids calling
-          # current_user which may trigger DB queries or auth logic)
+        def extract_user_id
           cached = Fiber[:opentrace_cached_context]
-          return cached[:user_id] if cached&.key?(:user_id)
-
-          controller = payload[:controller_instance]
-          return unless controller
-
-          if controller.respond_to?(:current_user, true)
-            user = controller.send(:current_user)
-            user.respond_to?(:id) ? user.id : nil
-          end
+          cached[:user_id] if cached&.key?(:user_id)
         rescue StandardError
           nil
         end

data/lib/opentrace/request_collector.rb

@@ -12,6 +12,7 @@ module OpenTrace
 
     def initialize(max_timeline: MAX_TIMELINE_EVENTS)
       @max_timeline = max_timeline
+      @timeline_enabled = max_timeline > 0
 
       @sql_count = 0
       @sql_total_ms = 0.0
@@ -36,8 +37,12 @@ module OpenTrace
       @memory_before = nil
       @memory_after = nil
 
-      @timeline = []
-      @request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      if @timeline_enabled
+        @timeline = []
+        @request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      else
+        @timeline = nil
+      end
     end
 
     def record_sql(name:, duration_ms:, table: nil)
@@ -49,7 +54,9 @@ module OpenTrace
         @sql_slowest_name = name
       end
 
-      append_timeline({ t: :sql, n: name, ms: duration_ms.round(1), at: offset_ms })
+      if @timeline_enabled
+        append_timeline({ t: :sql, n: name, ms: duration_ms.round(1), at: offset_ms })
+      end
     end
 
     def record_view(template:, duration_ms:)
@@ -61,7 +68,9 @@ module OpenTrace
         @view_slowest_template = template
       end
 
-      append_timeline({ t: :view, n: template, ms: duration_ms.round(1), at: offset_ms })
+      if @timeline_enabled
+        append_timeline({ t: :view, n: template, ms: duration_ms.round(1), at: offset_ms })
+      end
     end
 
     def record_cache(action:, hit: nil, duration_ms: 0.0)
@@ -75,7 +84,9 @@ module OpenTrace
         @cache_deletes += 1
       end
 
-      append_timeline({ t: :cache, a: action, hit: hit, ms: duration_ms.round(2), at: offset_ms })
+      if @timeline_enabled
+        append_timeline({ t: :cache, a: action, hit: hit, ms: duration_ms.round(2), at: offset_ms })
+      end
     end
 
     def record_http(method:, url:, host:, status:, duration_ms:, error: nil)
@@ -87,9 +98,11 @@ module OpenTrace
         @http_slowest_host = host
       end
 
-      entry = { t: :http, n: "#{method} #{host}", ms: duration_ms.round(1), s: status, at: offset_ms }
-      entry[:err] = error if error
-      append_timeline(entry)
+      if @timeline_enabled
+        entry = { t: :http, n: "#{method} #{host}", ms: duration_ms.round(1), s: status, at: offset_ms }
+        entry[:err] = error if error
+        append_timeline(entry)
+      end
     end
 
     def summary
@@ -107,7 +120,7 @@ module OpenTrace
         cache_writes: @cache_writes,
         cache_hit_ratio: @cache_reads > 0 ? (@cache_hits.to_f / @cache_reads).round(2) : nil,
         n_plus_one_warning: @sql_count > 20 ? true : nil,
-        timeline: @timeline.empty? ? nil : @timeline
+        timeline: (@timeline.nil? || @timeline.empty?) ? nil : @timeline
       }
 
       # HTTP stats (only present if calls were made)

data/lib/opentrace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenTrace
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opentrace
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - OpenTrace