railswatch_gem 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4ab7fecdace81bbd2d66eb61b06026abb547c6815fc59c67fb1137bd9aea0bd
-  data.tar.gz: 68fccbf28d63b0f133bd9a5d9ef19d93263d913686b7526726aa3b0b170f75aa
+  metadata.gz: b46c253056a39e43ac5a606710eba79ec8685088111637d802580d3fa9d66388
+  data.tar.gz: 79146492b64604e69b19909338a0bf42892b13410b7ee49f9470715c4e8f5615
 SHA512:
-  metadata.gz: d0bb1ccbf5d4a199990f9a20bb5ebc937a3eeccef63761d54cf301b1d29977672767ee9815cb7309788cfdcf01769118cde1b2528e70f7140d7f47817545c99c
-  data.tar.gz: a757ce0625f2a52679d44a93c5b0ee13c188b66f304a76888396ede5e1d3c42f144bd2c813eadcd8aeb7c31593034ddd74c1aad6e113ce73ac50a1d10b4e1a05
+  metadata.gz: cc4617eb9907496f98e26384db7477fd0a10ffab8dd29462614436e9f284d50fed7c538b7dad3c1ac08cc94be9be952275e2c8dff6129c8ee03267fac45efe32
+  data.tar.gz: e29e08b277c75b8512290d734eb0cd9f3e3b16b112060019b12b01592dc8067d070387636e45b99e38feaaea9b13064e5e81d053f0524eaf7ad39644e8cb61a7

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailswatchGem
-  VERSION = "0.1.3"
+  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.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Tyler Hammett