railswatch_gem 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb0eec72b0b4b1904079261950d3780b713f068f25dc2347c1d606369b86b083
-  data.tar.gz: f390ff3575ed2c6b6df73fc0dbb2ee64f176169d51a7cdb733e4d7cc0f591036
+  metadata.gz: a4ab7fecdace81bbd2d66eb61b06026abb547c6815fc59c67fb1137bd9aea0bd
+  data.tar.gz: 68fccbf28d63b0f133bd9a5d9ef19d93263d913686b7526726aa3b0b170f75aa
 SHA512:
-  metadata.gz: 549bd28842b55b51cb78112d5c03e971abce96cb5d15983defa211f7814f984ef869b1575dc022b93c9c554ceec4e02907671b48de001bf691bdaa38dd4f3401
-  data.tar.gz: 3b7d77f1529eb2a8b35f745426867ea2c8e202e75f5044bf2ea126690be17963862709099665beafc3b0ce546cffb3ae8ce2e7e098320406e87f90f8b64e5e92
+  metadata.gz: d0bb1ccbf5d4a199990f9a20bb5ebc937a3eeccef63761d54cf301b1d29977672767ee9815cb7309788cfdcf01769118cde1b2528e70f7140d7f47817545c99c
+  data.tar.gz: a757ce0625f2a52679d44a93c5b0ee13c188b66f304a76888396ede5e1d3c42f144bd2c813eadcd8aeb7c31593034ddd74c1aad6e113ce73ac50a1d10b4e1a05

data/lib/railswatch_gem/instrumentation/cache_instrumenter.rb

@@ -25,16 +25,21 @@ module RailswatchGem
         name = event.name # e.g., "cache_read.active_support"
 
         # Extract action from name: cache_read.active_support -> read
-        # Common actions: read, write, delete, fetch_hit, generate
         action = name.split(".").first.sub("cache_", "")
 
+        # Capture source location (Where did we call Rails.cache.read?)
+        # We use the cleaner to ignore framework lines and find user code.
+        app_trace = ::Rails.backtrace_cleaner.clean(caller)
+
         data = {
           event_type: "cache",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
           action: action,
           key: payload[:key],
 
+          # Add Trace for debugging
+          backtrace: app_trace,
+
           # Performance
           duration_ms: event.duration.round(2)
         }

data/lib/railswatch_gem/instrumentation/commands_instrumenter.rb

@@ -11,7 +11,7 @@ module RailswatchGem
       end
 
       def start
-        # Hook into Thor to capture CLI commands (e.g., rails runner, rails generate, custom CLI tools)
+        # Hook into Thor to capture CLI commands (e.g., rails runner, rails generate)
         if defined?(::Thor::Command)
           patch_thor_commands
 
@@ -37,15 +37,14 @@ module RailswatchGem
 
         data = {
           event_type: "command",
-          # FIX: Handle Float timestamps safely using Time.at()
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Command Identity
           name: command_name,
           args: payload[:args],
           options: payload[:options],
 
-          # Context (Optional: class name of the tool running, e.g., 'Rails::Generators::ModelGenerator')
+          # Context
           tool: payload[:tool_class],
 
           # Performance
@@ -71,9 +70,6 @@ module RailswatchGem
       # ----------------------------------------------------------------
       module ThorCommandPatch
         def run(instance, args = [])
-          # Thor::Command#run(instance, args)
-          # 'name' is available on the command object
-
           # Capture options if available on the instance (parsed flags)
           opts = instance.respond_to?(:options) ? instance.options : nil
           tool_class = instance.class.name

data/lib/railswatch_gem/instrumentation/errors_instrumenter.rb

@@ -9,9 +9,6 @@ module RailswatchGem
       end
 
       def start
-        # This instrumenter relies on the Rails 7.0+ Error Reporter interface.
-        # It allows capturing both unhandled exceptions and manually reported errors
-        # (e.g., via Rails.error.handle { ... }).
         if defined?(::Rails) && ::Rails.respond_to?(:error)
           ::Rails.error.subscribe(ErrorSubscriber.new(@client))
         end
@@ -22,42 +19,47 @@ module RailswatchGem
           @client = client
         end
 
-        # The signature required by Rails.error.subscribe
         def report(error, handled:, severity:, context:, source: nil)
-          # 1. Infinite Loop Protection:
-          # Don't report errors originating from our own gem to prevent recursion.
+          # 1. Infinite Loop Protection
           return if error.class.name.start_with?("RailswatchGem::")
 
-          # 2. Context Correlation:
-          # Try to link this error to the current HTTP request if possible.
-          # We check the passed context first, then fall back to our thread-local storage.
+          # 2. Capture Backtrace Smartly
+          # If error.backtrace is nil (un-raised exception), use the current caller.
+          raw_trace = error.backtrace || caller
+
+          # Clean the trace to remove framework noise (gems, rails internals)
+          # This ensures we see the User's code, not the Gem's code.
+          clean_trace = if defined?(::Rails.backtrace_cleaner)
+                          ::Rails.backtrace_cleaner.clean(raw_trace)
+                        else
+                          raw_trace
+                        end
+
+          # 3. Context Correlation
           request_id = context[:request_id] || Thread.current[:railswatch_request_id]
 
           data = {
             event_type: "error",
-            timestamp: Time.now.utc.iso8601,
+            timestamp: Time.now.utc.iso8601(6),
 
             # Exception Details
             class: error.class.name,
             message: error.message,
-            # Limit backtrace to save bandwidth; the dashboard usually only needs the top frames.
-            backtrace: (error.backtrace || []).first(25),
 
-            # Rails Error Reporter Context
+            backtrace: clean_trace.first(25),
+
+            # Rails Context
             handled: handled,
             severity: severity,
-            source: source, # e.g., "application.job"
+            source: source,
 
             # Correlation
             request_id: request_id,
-
-            # Extra context passed to Rails.error.report(e, context: { user_id: 1 })
             context: context
           }
 
           @client.record(data)
         rescue => e
-          # Absolute safety net: If reporting the error fails, print to stderr and move on.
           warn "RailswatchGem: Failed to report error event: #{e.message}"
         end
       end

data/lib/railswatch_gem/instrumentation/jobs_instrumenter.rb

@@ -12,7 +12,6 @@ module RailswatchGem
 
       def start
         # Subscribe to the execution event.
-        # "enqueue.active_job" is also available if you want to track queue depth/latency separately.
         ActiveSupport::Notifications.subscribe("perform.active_job") do |*args|
           event = ActiveSupport::Notifications::Event.new(*args)
           process_event(event)
@@ -25,13 +24,21 @@ module RailswatchGem
         payload = event.payload
         job = payload[:job]
 
-        # Guard against malformed payloads (though rare in ActiveJob)
         return unless job
 
+        # Safely serialize arguments (GlobalID or primitives)
+        # We use standard ActiveJob serialization to get readable values
+        serialized_args = begin
+          job.arguments.map do |arg|
+            arg.respond_to?(:to_global_id) ? arg.to_global_id.to_s : arg.inspect
+          end
+        rescue
+          ["(unserializable args)"]
+        end
+
         data = {
           event_type: "job",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Job Identity
           job_class: job.class.name,
@@ -39,6 +46,9 @@ module RailswatchGem
           queue_name: job.queue_name,
           priority: job.priority,
 
+          #  Arguments allow debugging "Which user failed?"
+          arguments: serialized_args,
+
           # Execution Context
           adapter: payload[:adapter]&.class&.name,
           executions: job.executions,
@@ -47,12 +57,11 @@ module RailswatchGem
           duration_ms: event.duration.round(2)
         }
 
-        # Calculate Queue Latency: Time spent waiting in the queue
+        # Calculate Queue Latency
         if job.enqueued_at
           enqueued_time = Time.iso8601(job.enqueued_at) rescue nil
           if enqueued_time
-            # Start of processing - Time enqueued
-            # FIX: Convert event.time (Float) to Time before subtraction
+            # Fix: Ensure event.time is converted to Time object
             latency = (Time.at(event.time) - enqueued_time) * 1000
             data[:queue_latency_ms] = latency.round(2)
           end
@@ -60,7 +69,6 @@ module RailswatchGem
 
         # Error handling
         if payload[:exception]
-          # payload[:exception] is [ClassName, Message]
           data[:error_class] = payload[:exception].first.to_s
           data[:error_message] = payload[:exception].last.to_s
         end

data/lib/railswatch_gem/instrumentation/logs_instrumenter.rb

@@ -11,20 +11,12 @@ module RailswatchGem
       end
 
       def start
-        # Only attach if Rails logger is available
         return unless defined?(::Rails) && ::Rails.logger
 
         target_logger = ::Rails.logger
-
-        # Avoid double patching if called multiple times
         return if target_logger.respond_to?(:_railswatch_instrumented?)
 
-        # Create the interception module bound to our client
         interceptor = create_interceptor(@client)
-
-        # Extend the specific logger instance.
-        # This inserts the module into the object's singleton class inheritance chain,
-        # effectively wrapping the 'add' method.
         target_logger.extend(interceptor)
       end
 
@@ -32,21 +24,15 @@ module RailswatchGem
 
       def create_interceptor(client)
         Module.new do
-          # FIX: We use define_method here to create a closure over the 'client' variable.
-          # Standard 'def' methods create a new scope and cannot access outer local variables.
-          # We expose client as a private method so 'add' can access it.
           define_method(:_railswatch_client) { client }
           private :_railswatch_client
 
-          # The primary entry point for Ruby Logger
           def add(severity, message = nil, progname = nil, &block)
-            # PERFORMANCE: Check level first.
             if respond_to?(:level) && severity < level
               return super
             end
 
             begin
-              # Resolve the message content.
               log_message = message
               if log_message.nil?
                 if block_given?
@@ -58,13 +44,11 @@ module RailswatchGem
 
               # INFINITE LOOP PROTECTION
               unless log_message.to_s.include?("[Railswatch]")
-
                 request_id = Thread.current[:railswatch_request_id]
 
-                # FIX: Access client via the closure-captured helper method
                 _railswatch_client.record({
                   event_type: "log",
-                  timestamp: Time.now.utc.iso8601,
+                  timestamp: Time.now.utc.iso8601(6),
                   severity: format_severity_level(severity),
                   message: log_message.to_s,
                   progname: progname,
@@ -74,13 +58,12 @@ module RailswatchGem
 
               super(severity, log_message, nil)
             rescue => e
-              # Fallback: If our instrumentation fails, ensure the app's logging continues.
+              # Fail safe: don't crash the app if logging fails
               $stderr.puts "RailswatchGem: LogsInstrumenter error: #{e.message}"
               super
             end
           end
 
-          # Marker method to prevent double-patching
           def _railswatch_instrumented?
             true
           end

data/lib/railswatch_gem/instrumentation/mail_instrumenter.rb

@@ -11,8 +11,6 @@ module RailswatchGem
       end
 
       def start
-        # Subscribe to the delivery event.
-        # "process.action_mailer" is also available if you want to track template rendering time separately.
         ActiveSupport::Notifications.subscribe("deliver.action_mailer") do |*args|
           event = ActiveSupport::Notifications::Event.new(*args)
           process_event(event)
@@ -24,35 +22,35 @@ module RailswatchGem
       def process_event(event)
         payload = event.payload
 
-        # Payload keys depend on Rails version, but generally include:
-        # :mailer, :message_id, :subject, :to, :from, :bcc, :cc, :date
-
-        # Calculate recipient count for metrics
         to_count = Array(payload[:to]).size
         cc_count = Array(payload[:cc]).size
         bcc_count = Array(payload[:bcc]).size
         total_recipients = to_count + cc_count + bcc_count
 
+        # Attempt to correlate with parent request (e.g. "Reset Password" controller action)
+        request_id = Thread.current[:railswatch_request_id]
+
         data = {
           event_type: "mail",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Identity
-          mailer: payload[:mailer], # The class name of the mailer
+          mailer: payload[:mailer],
           message_id: payload[:message_id],
 
-          # Content (Be careful with PII here)
+          # Content
           subject: payload[:subject],
           from: Array(payload[:from]).join(", "),
           to: Array(payload[:to]).join(", "),
 
           # Metrics
           recipient_count: total_recipients,
-          duration_ms: event.duration.round(2)
+          duration_ms: event.duration.round(2),
+
+          # Correlation
+          request_id: request_id
         }
 
-        # Error handling
         if payload[:exception]
           data[:error_class] = payload[:exception].first.to_s
           data[:error_message] = payload[:exception].last.to_s

data/lib/railswatch_gem/instrumentation/models_instrumenter.rb

@@ -10,8 +10,6 @@ module RailswatchGem
 
       def start
         return unless defined?(::ActiveRecord::Base)
-
-        # Inject our tracking module into ActiveRecord
         ::ActiveRecord::Base.include(Tracker)
       end
 
@@ -19,8 +17,6 @@ module RailswatchGem
         extend ActiveSupport::Concern
 
         included do
-          # We use after_commit to ensure we only report data that actually persisted.
-          # We pass 'self' to the callbacks.
           after_commit :_railswatch_handle_create, on: :create
           after_commit :_railswatch_handle_update, on: :update
           after_commit :_railswatch_handle_destroy, on: :destroy
@@ -41,29 +37,25 @@ module RailswatchGem
         private
 
         def _railswatch_record_event(type)
-          # Guard: Avoid tracking internal Rails models or strict excludes
-          return if self.class.name.start_with?("ActiveRecord::", "RailswatchGem::")
+          # Guard: Avoid tracking internal Rails models, gem models, or schema migrations
+          return if self.class.name.start_with?("ActiveRecord::", "RailswatchGem::", "Ahoy::", "PaperTrail::")
 
-          # Retrieve Request ID if available for correlation
           request_id = Thread.current[:railswatch_request_id]
-
-          # Calculate changes.
-          # Note: In after_commit, previous_changes is needed because changes is empty.
           changes_hash = previous_changes.dup
 
-          # Filter sensitive attributes (naive approach, can be improved with Rails.application.config.filter_parameters)
+          # Use Rails standard parameter filtering for maximum safety
           _railswatch_filter_attributes!(changes_hash)
 
           data = {
             event_type: "model",
-            action: type, # model_create, etc.
-            timestamp: Time.now.utc.iso8601,
+            action: type,
+            timestamp: Time.now.utc.iso8601(6),
 
             # Model Identity
             model: self.class.name,
             key: self.id,
 
-            # The actual data changed
+            # Data
             changes: changes_hash,
 
             # Correlation
@@ -72,17 +64,24 @@ module RailswatchGem
 
           RailswatchGem.record(data)
         rescue => e
-          # Swallow errors to prevent model callbacks from aborting transactions
           warn "RailswatchGem: Failed to record model event: #{e.message}"
         end
 
         def _railswatch_filter_attributes!(hash)
-          # Basic filtration of common sensitive fields
-          sensitive = %w[password password_digest token secret credit_card cc_number]
-          hash.each_key do |key|
-            if sensitive.any? { |s| key.to_s.include?(s) }
-              hash[key] = ["[FILTERED]", "[FILTERED]"]
-            end
+          if defined?(::Rails.application) && ::Rails.application
+             # Use the app's real configuration
+             filter = ActiveSupport::ParameterFilter.new(::Rails.application.config.filter_parameters)
+             # Filter keys (parameter filter expects a hash, usually params, but works on attributes too)
+             filtered = filter.filter(hash)
+             hash.replace(filtered)
+          else
+             # Fallback
+             sensitive = %w[password password_digest token secret credit_card cc_number]
+             hash.each_key do |key|
+               if sensitive.any? { |s| key.to_s.include?(s) }
+                 hash[key] = ["[FILTERED]", "[FILTERED]"]
+               end
+             end
           end
         end
       end

data/lib/railswatch_gem/instrumentation/notifications_instrumenter.rb

@@ -11,20 +11,12 @@ module RailswatchGem
       end
 
       def start
-        # This instrumenter allows users to track arbitrary ActiveSupport::Notifications.
-        # It relies on the user defining 'tracked_notifications' in the configuration.
-        #
-        # Example Config usage:
-        #   config.tracked_notifications = ["billing.checkout", /users\..*/]
-
         patterns = if @config.respond_to?(:tracked_notifications)
                      @config.tracked_notifications
                    else
                      []
                    end
 
-        # FIX: Use .map instead of .each to return the array of subscribers.
-        # This allows tests (and apps) to keep track of subscriptions and unsubscribe if needed.
         Array(patterns).map do |pattern|
           ActiveSupport::Notifications.subscribe(pattern) do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
@@ -36,27 +28,27 @@ module RailswatchGem
       private
 
       def process_event(event)
-        # Prevent infinite loops if the user accidentally subscribes to our own internal events
+        # Prevent infinite loops
         return if event.name.start_with?("railswatch_gem")
 
         payload = event.payload
+        request_id = Thread.current[:railswatch_request_id]
 
         data = {
           event_type: "notification",
           name: event.name,
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
-          duration_ms: event.duration.round(2)
+          timestamp: Time.at(event.time).utc.iso8601(6),
+          duration_ms: event.duration.round(2),
+          request_id: request_id
         }
 
-        # Safely merge primitive payload values to avoid serialization issues with complex objects
+        # Safe Payload Merge
         safe_payload = payload.select do |_, v|
           v.is_a?(String) || v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass) || v.nil?
         end
 
         data[:payload] = safe_payload
 
-        # Error handling
         if payload[:exception]
           data[:error_class] = payload[:exception].first.to_s
           data[:error_message] = payload[:exception].last.to_s

data/lib/railswatch_gem/instrumentation/outgoing_requests_instrumenter.rb

@@ -10,13 +10,10 @@ module RailswatchGem
       def initialize(client, config)
         @client = client
         @config = config
-        # Cache ingestion URI components for fast comparison
         @ingest_uri = URI(@config.ingest_url) rescue nil
       end
 
       def start
-        # Monkey-patch Net::HTTP if we haven't already.
-        # This wraps the low-level request method to emit an ActiveSupport notification.
         unless Net::HTTP.include?(NetHttpPatch)
           Net::HTTP.prepend(NetHttpPatch)
         end
@@ -33,17 +30,17 @@ module RailswatchGem
         payload = event.payload
 
         # CRITICAL: Ignore requests to the ingestion endpoint.
-        # This prevents an infinite loop where reporting metrics generates more metrics.
         if @ingest_uri &&
            payload[:host] == @ingest_uri.host &&
            payload[:port] == @ingest_uri.port
           return
         end
 
+        request_id = Thread.current[:railswatch_request_id]
+
         data = {
           event_type: "outgoing_request",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Request Details
           method: payload[:method],
@@ -53,11 +50,13 @@ module RailswatchGem
           scheme: payload[:scheme],
           path: payload[:path],
 
+          # Correlation
+          request_id: request_id,
+
           # Performance
           duration_ms: event.duration.round(2)
         }
 
-        # Error handling
         if payload[:exception]
           data[:error_class] = payload[:exception].first.to_s
           data[:error_message] = payload[:exception].last.to_s
@@ -68,15 +67,9 @@ module RailswatchGem
         warn "RailswatchGem: Failed to process outgoing request event: #{e.message}"
       end
 
-      # ----------------------------------------------------------------
-      # Internal Patch for Net::HTTP
-      # ----------------------------------------------------------------
       module NetHttpPatch
         def request(req, body = nil, &block)
           scheme = use_ssl? ? "https" : "http"
-
-          # Reconstruct basic URI for context
-          # Note: address and port are methods on the Net::HTTP instance
           uri = URI("#{scheme}://#{address}:#{port}#{req.path}")
 
           ActiveSupport::Notifications.instrument("request.net_http", {

data/lib/railswatch_gem/instrumentation/queries_instrumenter.rb

@@ -28,20 +28,26 @@ module RailswatchGem
         name = payload[:name]
         return if name && IGNORED_NAMES.include?(name)
 
-        # Basic PII safety: You might want to sanitize SQL here depending on your needs.
-        # payload[:sql] usually contains the raw SQL with bound parameters injected
-        # if config.filter_parameters is not applied manually.
+        # 1. Capture the Application Trace
+        # Rails.backtrace_cleaner removes framework noise (gems, rails internals)
+        # leaving only the lines relevant to the user's application code.
+        app_trace = ::Rails.backtrace_cleaner.clean(caller)
 
+        # Basic PII safety: You might want to sanitize SQL here depending on your needs.
         data = {
           event_type: "query",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+
+          # Without this, the query logs might look 0ms off from the request logs.
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Query Details
           name: name || "SQL",
           sql: payload[:sql],
           cached: payload[:cached] || false,
 
+          # The New Field
+          backtrace: app_trace,
+
           # Performance
           duration_ms: event.duration.round(2)
         }
@@ -49,6 +55,11 @@ module RailswatchGem
         # Add connection_id if useful for debugging connection pool issues
         data[:connection_id] = payload[:connection_id] if payload[:connection_id]
 
+        # Link to the parent request if we are inside one
+        if (req_id = Thread.current[:railswatch_request_id])
+          data[:request_id] = req_id
+        end
+
         @client.record(data)
       rescue => e
         warn "RailswatchGem: Failed to process query event: #{e.message}"

data/lib/railswatch_gem/instrumentation/requests_instrumenter.rb

@@ -12,7 +12,6 @@ module RailswatchGem
 
       def start
         # Subscribe to the standard Rails controller event.
-        # This event includes details like status, path, duration, and DB runtime.
         ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
           event = ActiveSupport::Notifications::Event.new(*args)
           process_event(event)
@@ -40,8 +39,7 @@ module RailswatchGem
 
         data = {
           event_type: "request",
-          # Fix: Ensure timestamp is a Time object before calling utc
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
           request_id: request_id,
 
           # HTTP Context
@@ -109,17 +107,33 @@ module RailswatchGem
       def extract_user(headers)
         return nil unless headers.respond_to?(:env)
 
-        warden = headers.env["warden"]
-        if warden && warden.user
-          user = warden.user
-          {
+        env = headers.env
+
+        # 1. Try Warden (Devise)
+        warden = env["warden"]
+        if warden
+          # Warden proxy might not have loaded the user yet
+          user = warden.user(run_callbacks: false) rescue nil
+          if user
+            return {
+              id: user.respond_to?(:id) ? user.id : nil,
+              email: user.respond_to?(:email) ? user.email : nil,
+              class: user.class.name
+            }
+          end
+        end
+
+        # 2. Try CurrentAttributes (Modern Rails pattern)
+        if defined?(::Current) && ::Current.respond_to?(:user) && ::Current.user
+          user = ::Current.user
+          return {
             id: user.respond_to?(:id) ? user.id : nil,
             email: user.respond_to?(:email) ? user.email : nil,
             class: user.class.name
           }
-        else
-          nil
         end
+
+        nil
       rescue
         nil
       end

data/lib/railswatch_gem/instrumentation/scheduled_tasks_instrumenter.rb

@@ -12,7 +12,6 @@ module RailswatchGem
 
       def start
         # Only instrument Rake if it is loaded.
-        # This prevents errors if the gem is used in a context where Rake isn't present.
         if defined?(::Rake::Task)
           patch_rake_tasks
 
@@ -36,20 +35,25 @@ module RailswatchGem
         payload = event.payload
         task_name = payload[:name]
 
-        # Optional: Ignore internal Railswatch tasks to prevent noise
+        # Ignore internal Railswatch tasks to prevent noise/loops
         return if task_name.to_s.start_with?("railswatch:")
 
+        # Check for correlation (e.g. if task was triggered from a controller)
+        request_id = Thread.current[:railswatch_request_id]
+
         data = {
           event_type: "scheduled_task",
-          # FIX: Handle Float timestamps safely
-          timestamp: Time.at(event.end).utc.iso8601,
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Task Identity
           name: task_name,
-          args: payload[:args].to_a, # Rake args come as a wrapper, convert to array
+          args: payload[:args].to_a,
 
           # Performance
-          duration_ms: event.duration.round(2)
+          duration_ms: event.duration.round(2),
+
+          # Correlation
+          request_id: request_id
         }
 
         # Error handling
@@ -71,7 +75,6 @@ module RailswatchGem
       # ----------------------------------------------------------------
       module RakeTaskPatch
         def execute(args = nil)
-          # We explicitly capture 'name' here because it's available on the task instance
           ActiveSupport::Notifications.instrument("task.rake", { name: name, args: args }) do
             super
           end

data/lib/railswatch_gem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailswatchGem
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railswatch_gem
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Tyler Hammett