logtail-rails 0.2.13 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 199f2f2bf589ef69bbe057b16224aa71999e45e991e30eeda9533f11ce233c79
-  data.tar.gz: 26603038e5aa56d21112ce259084999f4cf29df2eab4b1b411f13d0cef6ae246
+  metadata.gz: 69e0f9b99939d4b4ab4c3b5b185f09fcc824120618371f8881e10b671b49a218
+  data.tar.gz: 47c66f5323fbab6dd1b1fe2e559cce6097c13c540cd5ce7b5c2b8cb857a65b4b
 SHA512:
-  metadata.gz: fb36a1279648ec39acebf782e59b26441824b1222152ba76c44cc7454ae0593eaece3beca230d3e305ae803e4215c958a3f51e5cadb962ee3592060b45ed8357
-  data.tar.gz: e267ac9f6488ec482c1b84035cb119e6062f3f335e03bedb8eff3cae3fd318a5a5e61dacc560acca8eb53870080a89add3006b7299454b4b2025d1b738d2a4a4
+  metadata.gz: 3378d7cf4c494bc061759ca956239472c8ad9d1f4066d47cba0e0ef7c975ea50e0be2ecc91ec9a778a9d00d78e3f79e8347092505b5a4b8a03de03c902e7fa67
+  data.tar.gz: 6b873bad4830cfe29f52958d5b9493e0c3b0c7ddb634eabe3f6719860722e947548f710ac9b99aecd0e997105a3a1350933df4e85436889b9c0e3db08296a5f5

data/README.md

@@ -14,6 +14,8 @@ Experience SQL-compatible structured log management based on ClickHouse. [Learn
 
 [Getting started ⇗](https://betterstack.com/docs/logs/ruby-and-rails/#logging-from-rails)
 
+To turn the integration off in an environment, e.g. development or test, set `config.logtail.enabled = false` in `config/environments/<environment>.rb`. Rails then logs to `log/<environment>.log` as usual, even if `config/application.rb` creates the Better Stack logger.
+
 ## Need help?
 Please let us know at [hello@betterstack.com](mailto:hello@betterstack.com). We're happy to help!
 

data/lib/logtail-rails/action_view/log_subscriber/logtail_log_subscriber.rb

@@ -76,9 +76,12 @@ module Logtail
               super
 
               if ::Rails::VERSION::MAJOR > 7 || ::Rails::VERSION::MAJOR == 7 && ::Rails::VERSION::MINOR >= 1
-                # Clean extra listeners subscribed in parent's attach_to method
-                ::ActiveSupport::Notifications.notifier.listeners_for("render_template.action_view")
-                  .concat(::ActiveSupport::Notifications.notifier.listeners_for("render_layout.action_view")).flatten
+                # Clean extra listeners subscribed in parent's attach_to method. Since Rails 7.2 they count as
+                # silenced while ActionView::Base.logger is nil, as it is at boot, and listeners_for skips those.
+                # all_listeners_for returns the notifier's cached array, so don't concat onto it.
+                notifier = ::ActiveSupport::Notifications.notifier
+                %w(render_template.action_view render_layout.action_view)
+                  .flat_map { |name| notifier.respond_to?(:all_listeners_for) ? notifier.all_listeners_for(name) : notifier.listeners_for(name) }
                   .filter { |listener| listener.delegate.class == ::ActionView::LogSubscriber::Start }
                   .each { |listener| ActiveSupport::Notifications.unsubscribe(listener) }
               end

data/lib/logtail-rails/config.rb

@@ -10,3 +10,22 @@ Logtail::Config.instance.define_singleton_method(:logrageify!) do
   integrations.active_record.silence = true
   integrations.rack.http_events.collapse_into_single_event = true
 end
+
+module Logtail
+  class Config
+    # Turns the Rails integration on or off, it's on by default. Set it in `config/application.rb`
+    # or `config/environments/*.rb`, see {Logtail::Frameworks::Rails::Railtie} for what it turns off.
+    #
+    # @example Keep the standard Rails logging in development
+    #   # config/environments/development.rb
+    #   config.logtail.enabled = false
+    def enabled=(value)
+      @enabled = value
+    end
+
+    # Accessor method for {#enabled=}
+    def enabled?
+      @enabled != false
+    end
+  end
+end

data/lib/logtail-rails/error_event.rb

@@ -18,19 +18,15 @@ module Logtail
         # We determine this when the app loads to avoid the overhead on a per request basis.
         EXCEPTION_WRAPPER_TAKES_CLEANER = defined?(::ActionDispatch::ExceptionWrapper) &&
           !::ActionDispatch::ExceptionWrapper.instance_methods.include?(:env)
+        # config.action_dispatch.log_rescued_responses (Rails 7.0+), as ActionDispatch::DebugExceptions
+        # reads it. This gem silences its logging and logs the exception here instead.
+        LOG_RESCUED_RESPONSES_KEY = "action_dispatch.log_rescued_responses".freeze
 
         def call(env)
           begin
             status, headers, body = @app.call(env)
           rescue Exception => exception
-            Config.instance.logger.fatal do
-              backtrace = extract_backtrace(env, exception)
-              Events::Error.new(
-                name: exception.class.name,
-                error_message: exception.message,
-                backtrace: backtrace
-              )
-            end
+            log_exception(env, exception)
 
             raise exception
           end
@@ -38,6 +34,30 @@ module Logtail
 
         private
 
+        # Never raises, so that the exception of the app is the one that propagates.
+        def log_exception(env, exception)
+          return if !log_exception?(env, exception)
+
+          Config.instance.logger.fatal do
+            backtrace = extract_backtrace(env, exception)
+            Events::Error.new(
+              name: exception.class.name,
+              error_message: exception.message,
+              backtrace: backtrace
+            )
+          end
+        rescue StandardError => e
+          Config.instance.debug { "#{self.class.name} could not log #{exception.class}: #{e.inspect}" }
+        end
+
+        # Like DebugExceptions, skip rescued responses such as ActiveRecord::RecordNotFound when
+        # log_rescued_responses is false. Older Rails versions don't set it and log every exception.
+        def log_exception?(env, exception)
+          return true if !env.key?(LOG_RESCUED_RESPONSES_KEY) || env[LOG_RESCUED_RESPONSES_KEY]
+
+          !::ActionDispatch::ExceptionWrapper.rescue_responses.key?(exception.class.name)
+        end
+
         # Rails provides a backtrace cleaner, so we use it here.
         def extract_backtrace(env, exception)
           if defined?(::ActionDispatch::ExceptionWrapper)

data/lib/logtail-rails/event_log_subscriber.rb

@@ -6,7 +6,7 @@ module Logtail
       # them with all their data to Rails.logger, which sends them to Better Stack.
       class EventLogSubscriber
         # Rails logger instance
-        attr_reader :logger
+        attr_accessor :logger
 
         # Log level to use for logging events
         mattr_accessor :log_level, default: :info
@@ -14,6 +14,17 @@ module Logtail
         # Allows to disable the subscriber
         mattr_accessor :enabled, default: true
 
+        # Subscribes to Rails.event once. Later calls only hand the events to the new logger, so that
+        # calling Logtail::Logger.create_default_logger again doesn't log every event twice.
+        def self.subscribe(logger)
+          if @subscriber
+            @subscriber.logger = logger
+          else
+            @subscriber = new(logger)
+            ::Rails.event.subscribe(@subscriber)
+          end
+        end
+
         # Initialize the subscriber with a logger instance
         def initialize(logger)
           @logger = logger
@@ -43,14 +54,16 @@ module Logtail
 
         private
 
-        # Rails 8.2+ routes the framework's own instrumentation (controller calls, SQL queries,
-        # template renders, ...) through Rails.event as well. The Rails log subscribers, and ours
-        # replacing them, already log those, so only the application's own events are forwarded.
+        # Rails 8.1+ reports its own instrumentation (controller calls, SQL queries, template
+        # renders, ...) to Rails.event as well, through the ActiveSupport::StructuredEventSubscriber
+        # it attaches for each of its components. The Rails log subscribers, and ours replacing
+        # them, already log those, so only the application's own events are forwarded.
         def framework_event?(event)
-          return false unless defined?(::ActiveSupport::EventReporter::LogSubscriber)
+          return false unless defined?(::ActiveSupport::StructuredEventSubscriber)
 
-          ::ActiveSupport::EventReporter::LogSubscriber.descendants.any? do |log_subscriber|
-            event[:name].start_with?("#{log_subscriber.namespace}.")
+          ::ActiveSupport::StructuredEventSubscriber.descendants.any? do |bridge|
+            # The namespace attach_to recorded is a private reader on ActiveSupport::Subscriber
+            event[:name].start_with?("#{bridge.send(:namespace)}.")
           end
         end
 

data/lib/logtail-rails/logger.rb

@@ -49,6 +49,10 @@ module Logtail
     def self.create_logger(*io_devices_and_loggers)
       logger = Logtail::Logger.new(*io_devices_and_loggers)
 
+      # Rails applies config.log_level to Rails.logger while booting, but not to a logger added with broadcast_to later
+      log_level = Rails.application.config.log_level if ENV['LOG_LEVEL'].blank? && Rails.application
+      logger.level = ::ActiveSupport::Logger.const_get(log_level.to_s.upcase) if log_level
+
       tagged_logging_supported = Rails::VERSION::MAJOR >= 7 || Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR >= 1
       logger = ::ActiveSupport::TaggedLogging.new(logger) if tagged_logging_supported
 
@@ -79,7 +83,7 @@ module Logtail
       end
 
       # For Rails 8.1 and above, subscribe to the event system
-      Rails.event.subscribe(Logtail::Integrations::Rails::EventLogSubscriber.new(logger)) if Rails.respond_to?(:event)
+      Logtail::Integrations::Rails::EventLogSubscriber.subscribe(logger) if Rails.respond_to?(:event)
 
       logger
     end

data/lib/logtail-rails/railtie.rb

@@ -13,6 +13,26 @@ module Logtail
           Logtail::Config.instance.logger = Proc.new { ::Rails.logger }
         end
 
+        # `config.logtail.enabled = false` turns the integration off. The environment files are loaded
+        # by now, and Rails hasn't set up Rails.logger from config.logger yet.
+        initializer(:logtail_enabled, after: :load_environment_config, before: :initialize_logger) do |app|
+          next if app.config.logtail.enabled?
+
+          # Before the :logtail initializer below picks the middlewares
+          Integrations::Rails.enabled = false
+
+          # The setup docs create the logger in config/application.rb, i.e. in every environment. Log to the
+          # default log file instead, with a Logtail::Logger so that `logger.info("message", key: value)` works.
+          if app.config.logger.is_a?(Logtail::Logger)
+            log_file = app.paths["log"].first
+            FileUtils.mkdir_p(File.dirname(log_file))
+            # Opened like Rails opens it: Logger only writes its "# Logfile created" header into files it creates
+            file = File.open(log_file, "a")
+            file.binmode
+            app.config.logger = Logtail::Logger.create_logger(file)
+          end
+        end
+
         # Must be loaded after initializers so that we respect any Logtail configuration set
         initializer(:logtail, before: :build_middleware_stack, after: :load_config_initializers) do
           Integrations::Rails.integrate!

data/lib/logtail-rails/version.rb

@@ -1,7 +1,7 @@
 module Logtail
   module Integrations
     module Rails
-      VERSION = "0.2.13"
+      VERSION = "0.2.15"
     end
   end
 end

data/lib/logtail-rails.rb

@@ -39,6 +39,12 @@ module Logtail
       def self.integrate!
         return false if !enabled?
 
+        # Log the status Rails responds with when the app raises, the way ShowExceptions
+        # determines it: from config.action_dispatch.rescue_responses, 500 by default.
+        Logtail::Integrations::Rack::HTTPEvents.status_for_exception = lambda do |exception|
+          ::ActionDispatch::ExceptionWrapper.new(nil, exception).status_code
+        end
+
         ActionController.integrate!
         ActionDispatch.integrate!
         ActionView.integrate!

data/logtail-rails.gemspec

@@ -27,8 +27,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "logtail", "~> 0.1", ">= 0.1.14"
-  spec.add_runtime_dependency "logtail-rack", "~> 0.1"
+  spec.add_runtime_dependency "logtail", "~> 0.1", ">= 0.1.21"
+  spec.add_runtime_dependency "logtail-rack", "~> 0.2", ">= 0.2.9"
 
   spec.add_runtime_dependency 'activerecord', '>= 5.0.0'
   spec.add_runtime_dependency 'railties', '>= 5.0.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logtail-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.15
 platform: ruby
 authors:
 - Better Stack
@@ -18,7 +18,7 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.14
+        version: 0.1.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,21 +28,27 @@ dependencies:
         version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.14
+        version: 0.1.21
 - !ruby/object:Gem::Dependency
   name: logtail-rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement