railswatch_gem 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3c2f8707dde0136f3ec790ae46558c384646a71d656b3659f46473732a77b5c
-  data.tar.gz: edec55e909ad43675ba436fac4337ee23a228988b8348cba5a8b9e99322c2f20
+  metadata.gz: b46c253056a39e43ac5a606710eba79ec8685088111637d802580d3fa9d66388
+  data.tar.gz: 79146492b64604e69b19909338a0bf42892b13410b7ee49f9470715c4e8f5615
 SHA512:
-  metadata.gz: 189aad8fdc06a51766bb19e4b4ded13f2b037839ae14dff7e2db632b8f1ae7a20b52d46dc81e60c95acf7603db804c46eae5240e31da6081b0d49e8786f77846
-  data.tar.gz: 2d7c7ebeaf988bdffd24265bc5eb1cafe659f35b91e5bb5537725279e99de42db9ec646bd92f25b0623b32ca3924e8aa0d062d07d307a8fd0dab5c431ef99be3
+  metadata.gz: cc4617eb9907496f98e26384db7477fd0a10ffab8dd29462614436e9f284d50fed7c538b7dad3c1ac08cc94be9be952275e2c8dff6129c8ee03267fac45efe32
+  data.tar.gz: e29e08b277c75b8512290d734eb0cd9f3e3b16b112060019b12b01592dc8067d070387636e45b99e38feaaea9b13064e5e81d053f0524eaf7ad39644e8cb61a7

data/lib/railswatch_gem/instrumentation/cache_instrumenter.rb

@@ -33,7 +33,7 @@ module RailswatchGem
 
         data = {
           event_type: "cache",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
           action: action,
           key: payload[:key],
 

data/lib/railswatch_gem/instrumentation/commands_instrumenter.rb

@@ -37,7 +37,7 @@ module RailswatchGem
 
         data = {
           event_type: "command",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Command Identity
           name: command_name,

data/lib/railswatch_gem/instrumentation/errors_instrumenter.rb

@@ -23,7 +23,19 @@ module RailswatchGem
           # 1. Infinite Loop Protection
           return if error.class.name.start_with?("RailswatchGem::")
 
-          # 2. Context Correlation
+          # 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 = {
@@ -33,10 +45,10 @@ module RailswatchGem
             # Exception Details
             class: error.class.name,
             message: error.message,
-            # Limit backtrace to save bandwidth
-            backtrace: (error.backtrace || []).first(25),
 
-            # Rails Error Reporter Context
+            backtrace: clean_trace.first(25),
+
+            # Rails Context
             handled: handled,
             severity: severity,
             source: source,

data/lib/railswatch_gem/instrumentation/jobs_instrumenter.rb

@@ -38,7 +38,7 @@ module RailswatchGem
 
         data = {
           event_type: "job",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Job Identity
           job_class: job.class.name,

data/lib/railswatch_gem/instrumentation/logs_instrumenter.rb

@@ -13,72 +13,97 @@ module RailswatchGem
       def start
         return unless defined?(::Rails) && ::Rails.logger
 
-        target_logger = ::Rails.logger
-        return if target_logger.respond_to?(:_railswatch_instrumented?)
+        # The "Sidecar" Pattern:
+        # Create a dedicated logger for Railswatch and broadcast to it.
+        railswatch_logger = RemoteLogger.new(@client)
 
-        interceptor = create_interceptor(@client)
-        target_logger.extend(interceptor)
+        if defined?(::ActiveSupport::BroadcastLogger) && ::Rails.logger.is_a?(::ActiveSupport::BroadcastLogger)
+          # Rails 7.1+: Native Broadcast
+          ::Rails.logger.broadcast_to(railswatch_logger)
+        elsif defined?(::ActiveSupport::Logger) && ::ActiveSupport::Logger.respond_to?(:broadcast)
+          # Rails 6.0 - 7.0: ActiveSupport Broadcast
+          ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(railswatch_logger))
+        else
+          # Fallback: Manual Interceptor (This is what your spec hits)
+          attach_legacy_interceptor(::Rails.logger, railswatch_logger)
+        end
       end
 
       private
 
-      def create_interceptor(client)
-        Module.new do
-          define_method(:_railswatch_client) { client }
-          private :_railswatch_client
+      def attach_legacy_interceptor(target_logger, remote_logger)
+        return if target_logger.respond_to?(:_railswatch_instrumented?)
 
-          def add(severity, message = nil, progname = nil, &block)
-            if respond_to?(:level) && severity < level
-              return super
+        interceptor = Module.new do
+          define_method(:add) do |severity, message = nil, progname = nil, &block|
+            # FIX: Check the main logger's level BEFORE forwarding.
+            # 'level' here refers to target_logger.level
+            if severity < level
+              return super(severity, message, progname, &block)
             end
 
-            begin
-              log_message = message
-              if log_message.nil?
-                if block_given?
-                  log_message = yield
-                else
-                  log_message = progname
-                end
-              end
-
-              # INFINITE LOOP PROTECTION
-              unless log_message.to_s.include?("[Railswatch]")
-                request_id = Thread.current[:railswatch_request_id]
-
-                _railswatch_client.record({
-                  event_type: "log",
-                  timestamp: Time.now.utc.iso8601(6),
-                  severity: format_severity_level(severity),
-                  message: log_message.to_s,
-                  progname: progname,
-                  request_id: request_id
-                })
-              end
-
-              super(severity, log_message, nil)
-            rescue => e
-              # Fail safe: don't crash the app if logging fails
-              $stderr.puts "RailswatchGem: LogsInstrumenter error: #{e.message}"
-              super
-            end
-          end
+            # Forward to our remote logger logic (safe, won't crash)
+            remote_logger.add(severity, message, progname, &block)
 
-          def _railswatch_instrumented?
-            true
+            # Proceed with original logging
+            super(severity, message, progname, &block)
           end
 
-          private
+          def _railswatch_instrumented?; true; end
+        end
 
-          def format_severity_level(severity)
-            case severity
-            when 0, ::Logger::DEBUG then "DEBUG"
-            when 1, ::Logger::INFO  then "INFO"
-            when 2, ::Logger::WARN  then "WARN"
-            when 3, ::Logger::ERROR then "ERROR"
-            when 4, ::Logger::FATAL then "FATAL"
-            else "UNKNOWN"
-            end
+        target_logger.extend(interceptor)
+      end
+
+      # --- Inner Class: The Actual Logger Logic ---
+      class RemoteLogger < ::Logger
+        def initialize(client)
+          @client = client
+          super(nil) # No IO output
+          self.level = DEBUG # Capture everything sent to us (filtering happens upstream)
+        end
+
+        def add(severity, message = nil, progname = nil, &block)
+          # 1. Message Resolution
+          content = message || (block&.call) || progname
+
+          # 2. Guard Clauses
+          return true if content.nil?
+
+          str_message = content.to_s.strip
+          return true if str_message.empty?
+          return true if str_message.include?("[Railswatch]")
+
+          # 3. Record
+          record_log(severity, str_message, progname)
+
+          true
+        rescue => e
+          $stderr.puts "RailswatchGem: Logs error: #{e.message}"
+          true
+        end
+
+        private
+
+        def record_log(severity, message, progname)
+          @client.record({
+            event_type: "log",
+            timestamp: Time.now.utc.iso8601(6),
+            severity: format_severity_level(severity),
+            message: message,
+            progname: progname,
+            request_id: Thread.current[:railswatch_request_id]
+          })
+        end
+
+        def format_severity_level(severity)
+          case severity
+          when 0, ::Logger::DEBUG then "DEBUG"
+          when 1, ::Logger::INFO  then "INFO"
+          when 2, ::Logger::WARN  then "WARN"
+          when 3, ::Logger::ERROR then "ERROR"
+          when 4, ::Logger::FATAL then "FATAL"
+          else "UNKNOWN"
           end
         end
       end

data/lib/railswatch_gem/instrumentation/mail_instrumenter.rb

@@ -32,7 +32,7 @@ module RailswatchGem
 
         data = {
           event_type: "mail",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Identity
           mailer: payload[:mailer],

data/lib/railswatch_gem/instrumentation/notifications_instrumenter.rb

@@ -37,7 +37,7 @@ module RailswatchGem
         data = {
           event_type: "notification",
           name: event.name,
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
           duration_ms: event.duration.round(2),
           request_id: request_id
         }

data/lib/railswatch_gem/instrumentation/outgoing_requests_instrumenter.rb

@@ -40,7 +40,7 @@ module RailswatchGem
 
         data = {
           event_type: "outgoing_request",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Request Details
           method: payload[:method],

data/lib/railswatch_gem/instrumentation/queries_instrumenter.rb

@@ -38,7 +38,7 @@ module RailswatchGem
           event_type: "query",
 
           # Without this, the query logs might look 0ms off from the request logs.
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Query Details
           name: name || "SQL",

data/lib/railswatch_gem/instrumentation/requests_instrumenter.rb

@@ -39,7 +39,7 @@ module RailswatchGem
 
         data = {
           event_type: "request",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
           request_id: request_id,
 
           # HTTP Context

data/lib/railswatch_gem/instrumentation/scheduled_tasks_instrumenter.rb

@@ -43,7 +43,7 @@ module RailswatchGem
 
         data = {
           event_type: "scheduled_task",
-          timestamp: Time.at(event.end).utc.iso8601(6),
+          timestamp: Time.at(event.time).utc.iso8601(6),
 
           # Task Identity
           name: task_name,

data/lib/railswatch_gem/version.rb

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

metadata

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