logtail-rails 0.1.0

data/lib/logtail-rails/action_controller.rb

@@ -0,0 +1,17 @@
+require "logtail-rails/action_controller/log_subscriber"
+
+module Logtail
+  module Integrations
+    # Module for holding *all* ActionController integrations. See {Integration} for
+    # configuration details for all integrations.
+    module ActionController
+      extend Integration
+
+      def self.integrate!
+        return false if !enabled?
+
+        LogSubscriber.integrate!
+      end
+    end
+  end
+end

data/lib/logtail-rails/action_controller/log_subscriber.rb

@@ -0,0 +1,25 @@
+module Logtail
+  module Integrations
+    module ActionController
+      # Responsible for removing the default ActionController::LogSubscriber and installing
+      # the LogtailLogSubscriber
+      #
+      # @private
+      class LogSubscriber < Integrator
+        def initialize
+          require "action_controller/log_subscriber"
+          require "logtail-rails/action_controller/log_subscriber/logtail_log_subscriber"
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          return true if Logtail::Integrations::Rails::ActiveSupportLogSubscriber.subscribed?(:action_controller, LogtailLogSubscriber)
+
+          Logtail::Integrations::Rails::ActiveSupportLogSubscriber.unsubscribe!(:action_controller, ::ActionController::LogSubscriber)
+          LogtailLogSubscriber.attach_to(:action_controller)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Logtail
+  module Integrations
+    module ActionController
+      class LogSubscriber < Integrator
+        # The log subscriber that replaces the default `ActionController::LogSubscriber`.
+        # The intent of this subscriber is to, as transparently as possible, properly
+        # track events that are being logged here. This LogSubscriber will never change
+        # default behavior / log messages.
+        #
+        # @private
+        class LogtailLogSubscriber < ::ActionController::LogSubscriber
+          def start_processing(event)
+            return true if silence?
+
+            info do
+              payload = event.payload
+              params = payload[:params].except(*INTERNAL_PARAMS)
+              format = extract_format(payload)
+              format = format.to_s.upcase if format.is_a?(Symbol)
+
+              Events::ControllerCall.new(
+                controller: payload[:controller],
+                action: payload[:action],
+                format: format,
+                params: params
+              )
+            end
+          end
+
+          private
+          def extract_format(payload)
+            if payload.key?(:format)
+              payload[:format] # rails > 4.X
+            elsif payload.key?(:formats)
+              payload[:formats].first # rails 3.X
+            end
+          end
+
+          def silence?
+            ActionController.silence?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rails/action_dispatch.rb

@@ -0,0 +1,20 @@
+require "logtail-rails/action_dispatch/debug_exceptions"
+
+module Logtail
+  module Integrations
+    # Module for holding *all* ActionDispatch integrations. This
+    # module simply disables the exception tracking middleware so that our middleware
+    # works as expected.
+    module ActionDispatch
+      def self.enabled?
+        Rails::ErrorEvent.enabled?
+      end
+
+      def self.integrate!
+        return false if !enabled?
+
+        DebugExceptions.integrate!
+      end
+    end
+  end
+end

data/lib/logtail-rails/action_dispatch/debug_exceptions.rb

@@ -0,0 +1,51 @@
+module Logtail
+  module Integrations
+    module ActionDispatch
+      # Responsible for disabled logging in the ActionDispatch::DebugExceptions
+      # Rack middleware. We cannot simply remove the middleware because it is
+      # coupled with displaying an exception debug screen if debug exceptions is enabled.
+      #
+      # @private
+      class DebugExceptions < Integrator
+
+        # Patch for disabling logging
+        #
+        # @private
+        module InstanceMethods
+          def self.included(klass)
+            klass.class_eval do
+              private
+              def logger(*args)
+                nil
+              end
+            end
+          end
+        end
+
+        def initialize
+          begin
+            # Rails >= 3.1
+            require "action_dispatch/middleware/debug_exceptions"
+          rescue LoadError
+            # Rails < 3.1
+            require "action_dispatch/middleware/show_exceptions"
+          end
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          if defined?(::ActionDispatch::DebugExceptions) && !::ActionDispatch::DebugExceptions.include?(InstanceMethods)
+            ::ActionDispatch::DebugExceptions.send(:include, InstanceMethods)
+          end
+
+          if defined?(::ActionDispatch::ShowExceptions) && !::ActionDispatch::ShowExceptions.include?(InstanceMethods)
+            ::ActionDispatch::ShowExceptions.send(:include, InstanceMethods)
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rails/action_view.rb

@@ -0,0 +1,17 @@
+require "logtail-rails/action_view/log_subscriber"
+
+module Logtail
+  module Integrations
+    # Module for holding *all* ActionView integrations. See {Integration} for
+    # configuration details for all integrations.
+    module ActionView
+      extend Integration
+
+      def self.integrate!
+        return false if !enabled?
+
+        LogSubscriber.integrate!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Logtail
+  module Integrations
+    module ActionView
+      # Responsible for uninstalling the default `ActionView::LogSubscriber` and installing
+      # the LogtailLogSubscriber.
+      #
+      # @private
+      class LogSubscriber < Integrator
+        def initialize
+          require "action_view/log_subscriber"
+          require "logtail-rails/action_view/log_subscriber/logtail_log_subscriber"
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          return true if Logtail::Integrations::Rails::ActiveSupportLogSubscriber.subscribed?(:action_view, LogtailLogSubscriber)
+
+          Logtail::Integrations::Rails::ActiveSupportLogSubscriber.unsubscribe!(:action_view, ::ActionView::LogSubscriber)
+          LogtailLogSubscriber.attach_to(:action_view)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Logtail
+  module Integrations
+    module ActionView
+      class LogSubscriber < Integrator
+
+        # The log subscriber that replaces the default `ActionView::LogSubscriber`.
+        # The intent of this subscriber is to, as transparently as possible, properly
+        # track events that are being logged here.
+        #
+        # @private
+        class LogtailLogSubscriber < ::ActionView::LogSubscriber
+          def render_template(event)
+            return true if silence?
+
+            info do
+              full_name = from_rails_root(event.payload[:identifier])
+              message = "  Rendered #{full_name}"
+              message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+              message << " (#{event.duration.round(1)}ms)"
+
+              Events::TemplateRender.new(
+                name: full_name,
+                duration_ms: event.duration,
+                message: message
+              )
+            end
+          end
+
+          def render_partial(event)
+            return true if silence?
+
+            info do
+              full_name = from_rails_root(event.payload[:identifier])
+              message = "  Rendered #{full_name}"
+              message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+              message << " (#{event.duration.round(1)}ms)"
+              message << " #{cache_message(event.payload)}" if event.payload.key?(:cache_hit)
+
+              Events::TemplateRender.new(
+                name: full_name,
+                duration_ms: event.duration,
+                message: message
+              )
+            end
+          end
+
+          def render_collection(event)
+            return true if silence?
+
+            if respond_to?(:render_count, true)
+              info do
+                identifier = event.payload[:identifier] || "templates"
+                full_name = from_rails_root(identifier)
+                message = "  Rendered collection of #{full_name}" \
+                  " #{render_count(event.payload)} (#{event.duration.round(1)}ms)"
+
+                Events::TemplateRender.new(
+                  name: full_name,
+                  duration_ms: event.duration,
+                  message: message
+                )
+              end
+            else
+              # Older versions of rails delegate this method to #render_template
+              render_template(event)
+            end
+          end
+
+          private
+          def log_rendering_start(*args)
+            # Consolidates 2 template rendering events into 1. We don't need 2 events for
+            # rendering a template. If you disagree, please feel free to open a PR and we
+            # can make this an option.
+            # *args is to be future proof for Rails 6.1, which adds another method argument
+          end
+
+          def silence?
+            ActionView.silence?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rails/active_record.rb

@@ -0,0 +1,17 @@
+require "logtail-rails/active_record/log_subscriber"
+
+module Logtail
+  module Integrations
+    # Module for holding *all* ActiveRecord integrations. See {Integration} for
+    # configuration details for all integrations.
+    module ActiveRecord
+      extend Integration
+
+      def self.integrate!
+        return false if !enabled?
+
+        LogSubscriber.integrate!
+      end
+    end
+  end
+end

data/lib/logtail-rails/active_record/log_subscriber.rb

@@ -0,0 +1,20 @@
+require "logtail-rails/active_record/log_subscriber/logtail_log_subscriber"
+
+module Logtail
+  module Integrations
+    module ActiveRecord
+      # Responsible for uninstalling the default `ActiveRecord::LogSubscriber` and replacing it
+      # with the `LogtailLogSubscriber`.
+      #
+      # @private
+      class LogSubscriber < Integrator
+        def integrate!
+          return true if Logtail::Integrations::Rails::ActiveSupportLogSubscriber.subscribed?(:active_record, LogtailLogSubscriber)
+
+          Logtail::Integrations::Rails::ActiveSupportLogSubscriber.unsubscribe!(:active_record, ::ActiveRecord::LogSubscriber)
+          LogtailLogSubscriber.attach_to(:active_record)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# We require all of ActiveRecord because the #logger method in ::ActiveRecord::LogSubscriber
+# uses ActiveRecord::Base. We can't require active_record/base directly because ActiveRecord
+# does not require files properly and we receive unintialized constant errors.
+require "active_record"
+require "active_record/log_subscriber"
+
+module Logtail
+  module Integrations
+    module ActiveRecord
+      class LogSubscriber < Integrator
+        # The log subscriber that replaces the default `ActiveRecord::LogSubscriber`.
+        # The intent of this subscriber is to, as transparently as possible, properly
+        # track events that are being logged here. This LogSubscriber will never change
+        # default behavior / log messages.
+        #
+        # @private
+        class LogtailLogSubscriber < ::ActiveRecord::LogSubscriber
+          def sql(event)
+            return true if silence?
+
+            r = super(event)
+
+            if @message
+              payload = event.payload
+
+              sql_event = Events::SQLQuery.new(
+                sql: payload[:sql],
+                duration_ms: event.duration,
+                message: @message,
+              )
+
+              logger.debug sql_event
+
+              @message = nil
+            end
+
+            r
+          end
+
+          private
+          def debug(message)
+            @message = message
+          end
+
+          def silence?
+            ActiveRecord.silence?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rails/active_support_log_subscriber.rb

@@ -0,0 +1,39 @@
+module Logtail
+  module Integrations
+    module Rails
+      # @private
+      module ActiveSupportLogSubscriber
+        extend self
+
+        def find(component, type)
+          ::ActiveSupport::LogSubscriber.log_subscribers.find do |subscriber|
+            subscriber.class == type
+          end
+        end
+
+        def subscribed?(component, type)
+          !find(component, type).nil?
+        end
+
+        # I don't know why this has to be so complicated, but it is. This code was taken from
+        # lograge :/
+        def unsubscribe!(component, type)
+          subscriber = find(component, type)
+
+          if !subscriber
+            raise "We could not find a log subscriber for #{component.inspect} of type #{type.inspect}"
+          end
+
+          events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+          events.each do |event|
+            ::ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+              if listener.instance_variable_get('@delegate') == subscriber
+                ::ActiveSupport::Notifications.unsubscribe listener
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rails/config.rb

@@ -0,0 +1,12 @@
+require 'logtail/config'
+require 'logtail-rack/config'
+require 'logtail-rails/config/action_view'
+require 'logtail-rails/config/active_record'
+require 'logtail-rails/config/action_controller'
+
+Logtail::Config.instance.define_singleton_method(:logrageify!) do
+  integrations.action_controller.silence = true
+  integrations.action_view.silence = true
+  integrations.active_record.silence = true
+  integrations.rack.http_events.collapse_into_single_event = true
+end