canonical_log 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 253b27b00b94bca86297424080c22fa4d64029b0795127e857573689c64e6bc0
-  data.tar.gz: 60a9e18dbd9ab02d0ee6e2024977bdc4fc99db6f5e54cf6a17e46a92be842bf9
+  metadata.gz: 0f2b86d164c19175dd3f83d60146ab61f4e31d382feb35033a7e616d07d785ff
+  data.tar.gz: 2539db431fc881bf3dc4da1b20788fc4a56bf0e512ec253975acd4bbbe019220
 SHA512:
-  metadata.gz: abd6f3d1791e3781b75b90f051cf994696b7aafee5652b4110a4bded2a176bcf1f1aeff4be38c47a86a36c0bc2cc69243a9d79984d8c718981172746125447ad
-  data.tar.gz: cd0993781e080dc276def869041a69a430e06603a46cd8110a4a6563dc4f01515fc6b50ee2c40845ef057d132f46527196eab150e89f44fe9bc76c5ecb53c9a8
+  metadata.gz: f5959c2e8cb0d5cfe2cd4327c55d908719caeb289fdf2d93d446a22c598a7bee936fccade3c320d9f88a7da31834ff71cfc0ae3f192386e090c0cdf8c2e6fd35
+  data.tar.gz: f86c56cd4f7efc2c7e62144e94743f6fa812506eaa69ab1c9f02f00872b3eb69a82beb92d39a8aca444fdc205c97167bdf86f24aae73e950a0f61c36a8939781

data/lib/canonical_log/configuration.rb

@@ -1,21 +1,43 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module CanonicalLog
   class Configuration
     attr_accessor :sinks, :param_filter_keys, :slow_query_threshold_ms,
                   :user_context, :before_emit, :ignored_paths,
-                  :sample_rate, :slow_request_threshold_ms, :sampling
+                  :sample_rate, :slow_request_threshold_ms, :sampling,
+                  :enabled, :suppress_rails_logging, :format,
+                  :filter_sql_literals, :filter_query_string,
+                  :log_level_resolver, :default_fields,
+                  :error_backtrace_lines
 
     def initialize
-      @sinks = :auto
-      @param_filter_keys = %w[password password_confirmation token secret]
-      @slow_query_threshold_ms = 100.0
-      @user_context = nil
-      @before_emit = nil
-      @ignored_paths = []
-      @sample_rate = 1.0            # Log everything by default
-      @slow_request_threshold_ms = 2000.0
-      @sampling = nil               # Custom sampling proc, receives (event_hash, config) -> bool
+      set_defaults
+      set_filter_defaults
+    end
+
+    def pretty=(value)
+      self.format = value ? :pretty : :json
+    end
+
+    def pretty?
+      format == :pretty
+    end
+
+    def resolve_log_level(event_hash)
+      if @log_level_resolver
+        @log_level_resolver.call(event_hash)
+      else
+        status = event_hash[:http_status].to_i
+        if event_hash[:error] || status >= 500
+          :error
+        elsif status >= 400
+          :warn
+        else
+          :info
+        end
+      end
     end
 
     def resolved_sinks
@@ -38,5 +60,53 @@ module CanonicalLog
         Sampling.sample?(event_hash, self)
       end
     end
+
+    def ignored_path?(path)
+      @ignored_paths.any? do |pattern|
+        case pattern
+        when Regexp then pattern.match?(path)
+        when String then path.start_with?(pattern)
+        end
+      end
+    end
+
+    def filtered_query(query)
+      params = URI.decode_www_form(query)
+      filtered = params.map do |key, value|
+        @param_filter_keys.include?(key) ? [key, '[FILTERED]'] : [key, value]
+      end
+      URI.encode_www_form(filtered)
+    rescue ArgumentError
+      query
+    end
+
+    private
+
+    def set_defaults
+      @sinks = :auto
+      @user_context = nil
+      @before_emit = nil
+      @ignored_paths = []
+      @sample_rate = 1.0
+      @slow_request_threshold_ms = 2000.0
+      @slow_query_threshold_ms = 100.0
+      @sampling = nil
+      @enabled = defined?(Rails) ? Rails.env.production? : true
+      @suppress_rails_logging = false
+      @format = :json
+      @log_level_resolver = nil
+      @default_fields = {}
+      @error_backtrace_lines = 5
+    end
+
+    def set_filter_defaults
+      @param_filter_keys = [
+        'password', 'password_confirmation', 'token', 'secret',
+        'secret_key', 'api_key', 'access_token', 'credit_card',
+        'card_number', 'cvv', 'ssn', 'authorization'
+      ]
+      @filter_sql_literals = true
+      @filter_query_string = true
+    end
   end
 end

data/lib/canonical_log/emitter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module Emitter
+    def self.emit!(event, config = CanonicalLog.configuration)
+      config.before_emit&.call(event)
+      event_hash = config.default_fields.merge(event.to_h)
+      return unless config.should_sample?(event_hash)
+
+      level = config.resolve_log_level(event_hash)
+      event_hash[:level] = level.to_s
+      event_hash[:message] ||= build_message(event_hash)
+      write_to_sinks(event_hash, config, level: level)
+    rescue StandardError => e
+      warn "[CanonicalLog] Emit error: #{e.message}"
+    end
+
+    def self.build_message(event_hash)
+      [event_hash[:http_method], event_hash[:path], event_hash[:http_status]].compact.join(' ')
+    end
+
+    def self.write_to_sinks(event_hash, config, level: :info)
+      json = serialize(event_hash, config)
+      config.resolved_sinks.each do |sink|
+        sink.write(json, level: level)
+      rescue StandardError => e
+        warn "[CanonicalLog] Sink error (#{sink.class}): #{e.message}"
+      end
+    end
+
+    def self.serialize(event_hash, config)
+      case config.format
+      when :pretty then CanonicalLog::Formatters::Pretty.format(event_hash)
+      when :logfmt then CanonicalLog::Formatters::Logfmt.format(event_hash)
+      else event_hash.to_json
+      end
+    end
+
+    private_class_method :build_message, :write_to_sinks, :serialize
+  end
+end

data/lib/canonical_log/event.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'time'
 
 module CanonicalLog
   class Event
-    CATEGORIES = %i[user business infra service].freeze
+    CATEGORIES = [:user, :business, :infra, :service].freeze
 
     def initialize
       @fields = {}
@@ -51,10 +52,13 @@ module CanonicalLog
     # Structured error capture
     def add_error(error, metadata = {})
       @mutex.synchronize do
-        @fields[:error] = {
+        backtrace_lines = CanonicalLog.configuration.error_backtrace_lines
+        error_hash = {
           class: error.class.name,
-          message: error.message
-        }.merge(metadata)
+          message: error.message,
+        }
+        error_hash[:backtrace] = error.backtrace.first(backtrace_lines) if backtrace_lines.positive? && error.backtrace
+        @fields[:error] = error_hash.merge(metadata)
       end
     end
 

data/lib/canonical_log/formatters/logfmt.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module Formatters
+    module Logfmt
+      def self.format(hash)
+        flatten(hash).map { |k, v| "#{k}=#{format_value(v)}" }.join(' ')
+      end
+
+      def self.flatten(hash, prefix = nil, result = {})
+        hash.each do |key, value|
+          full_key = prefix ? "#{prefix}.#{key}" : key.to_s
+          if value.is_a?(Hash)
+            flatten(value, full_key, result)
+          else
+            result[full_key] = value
+          end
+        end
+        result
+      end
+
+      def self.format_value(value)
+        case value
+        when nil then ''
+        when true, false, Numeric then value.to_s
+        when Array then maybe_quote(value.join(','))
+        else maybe_quote(value.to_s)
+        end
+      end
+
+      def self.maybe_quote(str)
+        if str.empty? || str.match?(/[\s="\\]/)
+          "\"#{str.gsub('\\', '\\\\\\\\').gsub('"', '\\"')}\""
+        else
+          str
+        end
+      end
+
+      private_class_method :flatten, :format_value, :maybe_quote
+    end
+  end
+end

data/lib/canonical_log/formatters/pretty.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CanonicalLog
+  module Formatters
+    module Pretty
+      CYAN = "\e[36m"
+      GREEN = "\e[32m"
+      YELLOW = "\e[33m"
+      MAGENTA = "\e[35m"
+      GRAY = "\e[90m"
+      RESET = "\e[0m"
+
+      def self.format(hash)
+        json = JSON.pretty_generate(hash)
+        colorize(json)
+      end
+
+      def self.colorize(json)
+        json.gsub(/("(?:[^"\\]|\\.)*")(\s*:)?|(\b(?:true|false)\b)|\bnull\b|(-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b)/) do
+          if Regexp.last_match(2)
+            "#{CYAN}#{Regexp.last_match(1)}#{RESET}#{Regexp.last_match(2)}"
+          elsif Regexp.last_match(1)
+            "#{GREEN}#{Regexp.last_match(1)}#{RESET}"
+          elsif Regexp.last_match(3)
+            "#{MAGENTA}#{Regexp.last_match(3)}#{RESET}"
+          elsif Regexp.last_match(0) == 'null'
+            "#{GRAY}null#{RESET}"
+          else
+            "#{YELLOW}#{Regexp.last_match(0)}#{RESET}"
+          end
+        end
+      end
+
+      private_class_method :colorize
+    end
+  end
+end

data/lib/canonical_log/integrations/error_enrichment.rb

@@ -18,7 +18,7 @@ module CanonicalLog
       rescue StandardError => e
         CanonicalLog.add(
           rescued_error_class: e.class.name,
-          rescued_error_message: e.message
+          rescued_error_message: e.message,
         )
         raise
       end

data/lib/canonical_log/integrations/sidekiq.rb

@@ -9,14 +9,14 @@ module CanonicalLog
         event.add(
           job_class: msg['class'],
           queue: queue,
-          jid: msg['jid']
+          jid: msg['jid'],
         )
 
         yield
       rescue Exception => e # rubocop:disable Lint/RescueException
         event&.add(
           error_class: e.class.name,
-          error_message: e.message
+          error_message: e.message,
         )
         raise
       ensure
@@ -30,17 +30,7 @@ module CanonicalLog
         event = Context.current
         return unless event
 
-        config = CanonicalLog.configuration
-        config.before_emit&.call(event)
-        json = event.to_json
-
-        config.resolved_sinks.each do |sink|
-          sink.write(json)
-        rescue StandardError => e
-          warn "[CanonicalLog] Sink error (#{sink.class}): #{e.message}"
-        end
-      rescue StandardError => e
-        warn "[CanonicalLog] Emit error: #{e.message}"
+        Emitter.emit!(event)
       end
     end
   end

data/lib/canonical_log/middleware.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module CanonicalLog
   class Middleware
     def initialize(app)
@@ -7,45 +9,73 @@ module CanonicalLog
     end
 
     def call(env)
-      return @app.call(env) if ignored_path?(env)
+      return @app.call(env) if skip?(env)
 
       Context.init!
       seed_request_fields(env)
-
-      status, headers, body = @app.call(env)
-      Context.current&.set(:http_status, status)
-      enrich_user_context(env)
-      [status, headers, body]
+      execute_request(env)
     rescue Exception => e # rubocop:disable Lint/RescueException
       Context.current&.add_error(e)
       Context.current&.set(:http_status, 500)
       raise
     ensure
-      emit! if Context.current
-      Context.clear!
+      finalize!
     end
 
     private
 
+    def skip?(env)
+      config = CanonicalLog.configuration
+      !config.enabled || config.ignored_path?(env['PATH_INFO'])
+    end
+
     def seed_request_fields(env)
       event = Context.current
       return unless event
 
-      request_id = env['action_dispatch.request_id'] ||
-                   env['HTTP_X_REQUEST_ID'] ||
-                   SecureRandom.uuid
-
       event.add(
-        request_id: request_id,
+        request_id: resolve_request_id(env),
         http_method: env['REQUEST_METHOD'],
         path: env['PATH_INFO'],
-        query_string: env['QUERY_STRING'].to_s.empty? ? nil : env['QUERY_STRING'],
+        query_string: resolve_query_string(env),
         remote_ip: env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'],
         user_agent: env['HTTP_USER_AGENT'],
-        content_type: env['CONTENT_TYPE']
+        content_type: env['CONTENT_TYPE'],
+      )
+
+      enrich_trace_context(event)
+    end
+
+    def resolve_request_id(env)
+      env['action_dispatch.request_id'] || env['HTTP_X_REQUEST_ID'] || SecureRandom.uuid
+    end
+
+    def resolve_query_string(env)
+      raw = env['QUERY_STRING'].to_s
+      return nil if raw.empty?
+
+      CanonicalLog.configuration.filter_query_string ? CanonicalLog.configuration.filtered_query(raw) : raw
+    end
+
+    def enrich_trace_context(event)
+      return unless defined?(OpenTelemetry::Trace)
+
+      span_context = OpenTelemetry::Trace.current_span.context
+      return unless span_context.valid?
+
+      event.add(
+        trace_id: span_context.hex_trace_id,
+        span_id: span_context.hex_span_id,
       )
     end
 
+    def execute_request(env)
+      status, headers, body = @app.call(env)
+      Context.current&.set(:http_status, status)
+      enrich_user_context(env)
+      [status, headers, body]
+    end
+
     def enrich_user_context(env)
       event = Context.current
       return unless event
@@ -72,41 +102,16 @@ module CanonicalLog
       nil
     end
 
+    def finalize!
+      emit! if Context.current
+      Context.clear!
+    end
+
     def emit!
       event = Context.current
       return unless event
 
-      config = CanonicalLog.configuration
-      config.before_emit&.call(event)
-
-      event_hash = event.to_h
-      return unless config.should_sample?(event_hash)
-
-      event_hash[:message] ||= build_message(event_hash)
-
-      json = event_hash.to_json
-
-      config.resolved_sinks.each do |sink|
-        sink.write(json)
-      rescue StandardError => e
-        warn "[CanonicalLog] Sink error (#{sink.class}): #{e.message}"
-      end
-    rescue StandardError => e
-      warn "[CanonicalLog] Emit error: #{e.message}"
-    end
-
-    def build_message(event_hash)
-      [event_hash[:http_method], event_hash[:path], event_hash[:http_status]].compact.join(' ')
-    end
-
-    def ignored_path?(env)
-      path = env['PATH_INFO']
-      CanonicalLog.configuration.ignored_paths.any? do |pattern|
-        case pattern
-        when Regexp then pattern.match?(path)
-        when String then path.start_with?(pattern)
-        end
-      end
+      Emitter.emit!(event)
     end
   end
 end

data/lib/canonical_log/rails_log_suppressor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module RailsLogSuppressor
+    SUPPRESSED_SUBSCRIBERS = [
+      'ActionController::LogSubscriber',
+      'ActionView::LogSubscriber',
+      'ActiveRecord::LogSubscriber',
+    ].freeze
+
+    def self.suppress!
+      suppress_log_subscribers!
+      suppress_rack_logger!
+    end
+
+    def self.suppress_log_subscribers!
+      null_logger = Logger.new(File::NULL)
+
+      ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+        next unless SUPPRESSED_SUBSCRIBERS.include?(subscriber.class.name)
+
+        subscriber.logger = null_logger
+      end
+    end
+
+    def self.suppress_rack_logger!
+      return unless defined?(Rails::Rack::Logger)
+
+      Rails::Rack::Logger.prepend(SilentRackLogger)
+    end
+
+    # Keeps Rails::Rack::Logger in the middleware stack (preserves tagged logging
+    # and request_id setup) but silences its log output.
+    module SilentRackLogger
+      private
+
+      def started_request_message(_request)
+        nil
+      end
+
+      def logger
+        @logger ||= Logger.new(File::NULL)
+      end
+    end
+  end
+end

data/lib/canonical_log/railtie.rb

@@ -2,6 +2,10 @@
 
 module CanonicalLog
   class Railtie < Rails::Railtie
+    config.after_initialize do
+      CanonicalLog::RailsLogSuppressor.suppress! if CanonicalLog.configuration.suppress_rails_logging
+    end
+
     initializer 'canonical_log.insert_middleware' do |app|
       app.middleware.insert(0, CanonicalLog::Middleware)
     end
@@ -9,6 +13,8 @@ module CanonicalLog
     initializer 'canonical_log.subscribe' do
       CanonicalLog::Subscribers::ActionController.subscribe!
       CanonicalLog::Subscribers::ActiveRecord.subscribe!
+      CanonicalLog::Subscribers::ActiveSupportCache.subscribe!
+      CanonicalLog::Subscribers::ActiveJob.subscribe! if defined?(ActiveJob)
     end
   end
 end

data/lib/canonical_log/sampling.rb

@@ -7,14 +7,10 @@ module CanonicalLog
       status = event_hash[:http_status] || 0
       duration = event_hash[:duration_ms] || 0
 
-      # Always keep errors
-      return true if status >= 500
-      return true if event_hash[:error]
-
-      # Always keep slow requests
+      # Always keep errors and slow requests
+      return true if status >= 500 || event_hash[:error]
       return true if duration >= config.slow_request_threshold_ms
 
-      # Sample the rest
       rand < config.sample_rate
     end
   end

data/lib/canonical_log/sinks/base.rb

@@ -5,7 +5,7 @@ module CanonicalLog
     # Duck-type interface for sinks.
     # Any object responding to #write(json_string) can be used as a sink.
     class Base
-      def write(json_string)
+      def write(json_string, level: :info)
         raise NotImplementedError, "#{self.class} must implement #write"
       end
     end

data/lib/canonical_log/sinks/null.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module Sinks
+    class Null < Base
+      def write(_json_string, level: :info)
+        # no-op
+      end
+    end
+  end
+end

data/lib/canonical_log/sinks/rails_logger.rb

@@ -3,8 +3,8 @@
 module CanonicalLog
   module Sinks
     class RailsLogger < Base
-      def write(json_string)
-        Rails.logger.info(json_string)
+      def write(json_string, level: :info)
+        Rails.logger.public_send(level, json_string)
       end
     end
   end

data/lib/canonical_log/sinks/stdout.rb

@@ -3,7 +3,7 @@
 module CanonicalLog
   module Sinks
     class Stdout < Base
-      def write(json_string)
+      def write(json_string, level: :info) # rubocop:disable Lint/UnusedMethodArgument -- interface compliance
         $stdout.puts(json_string)
       end
     end

data/lib/canonical_log/sql_sanitizer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module SqlSanitizer
+    # Matches single-quoted string literals (including escaped quotes)
+    STRING_LITERAL = /'(?:[^'\\]|\\.)*'/
+
+    # Matches numeric literals in value positions (after =, >, <, IN (, comma, etc.)
+    NUMERIC_LITERAL = /(?<=[\s=><,(])-?\b\d+(?:\.\d+)?\b/
+
+    def self.sanitize(sql)
+      return sql unless sql.is_a?(String)
+
+      result = sql.gsub(STRING_LITERAL, "'?'")
+      result.gsub(NUMERIC_LITERAL, '?')
+    end
+  end
+end

data/lib/canonical_log/subscribers/action_controller.rb

@@ -11,31 +11,45 @@ module CanonicalLog
       end
 
       def self.handle(notification)
+        return unless CanonicalLog.configuration.enabled
+
         event = Context.current
         return unless event
 
         payload = notification.payload
-        config = CanonicalLog.configuration
+        event.add(extract_fields(payload))
+      end
 
+      def self.extract_fields(payload)
         params = (payload[:params] || {}).except('controller', 'action')
-        filtered_params = filter_params(params, config.param_filter_keys)
+        filtered_params = filter_params(params, CanonicalLog.configuration.param_filter_keys)
 
-        event.add(
+        {
           controller: payload[:controller],
           action: payload[:action],
           format: payload[:format],
           params: filtered_params,
           view_runtime_ms: payload[:view_runtime]&.round(2),
-          db_runtime_ms: payload[:db_runtime]&.round(2)
-        )
+          db_runtime_ms: payload[:db_runtime]&.round(2),
+        }
       end
 
       def self.filter_params(params, filter_keys)
+        if defined?(ActiveSupport::ParameterFilter)
+          ActiveSupport::ParameterFilter.new(filter_keys).filter(params)
+        else
+          deep_filter(params, filter_keys)
+        end
+      end
+
+      def self.deep_filter(params, filter_keys)
         params.each_with_object({}) do |(key, value), filtered|
           filtered[key] = if filter_keys.include?(key.to_s)
                             '[FILTERED]'
                           elsif value.is_a?(Hash)
-                            filter_params(value, filter_keys)
+                            deep_filter(value, filter_keys)
+                          elsif value.is_a?(Array)
+                            value.map { |v| v.is_a?(Hash) ? deep_filter(v, filter_keys) : v }
                           else
                             value
                           end

data/lib/canonical_log/subscribers/active_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module Subscribers
+    module ActiveJob
+      def self.subscribe!
+        ActiveSupport::Notifications.subscribe('perform.active_job') do |*args|
+          notification = ActiveSupport::Notifications::Event.new(*args)
+          handle(notification)
+        end
+      end
+
+      def self.handle(notification)
+        return unless CanonicalLog.configuration.enabled
+
+        Context.init!
+        event = Context.current
+        enrich_job_fields(event, notification.payload)
+        event.set(:duration_ms, notification.duration.round(2))
+        Emitter.emit!(event)
+      ensure
+        Context.clear!
+      end
+
+      def self.enrich_job_fields(event, payload)
+        job = payload[:job]
+        event.add(
+          job_class: job.class.name,
+          queue: job.queue_name,
+          job_id: job.job_id,
+          executions: job.executions,
+          priority: job.priority,
+        )
+
+        return unless payload[:exception_object]
+
+        event.add(
+          error_class: payload[:exception_object].class.name,
+          error_message: payload[:exception_object].message,
+        )
+      end
+      private_class_method :enrich_job_fields
+    end
+  end
+end

data/lib/canonical_log/subscribers/active_record.rb

@@ -11,24 +11,35 @@ module CanonicalLog
       end
 
       def self.handle(notification)
+        return unless CanonicalLog.configuration.enabled
         event = Context.current
         return unless event
-
         payload = notification.payload
-        return if %w[SCHEMA CACHE].include?(payload[:name])
+        return if ['SCHEMA', 'CACHE'].include?(payload[:name])
+
+        track_query_metrics(event, notification.duration)
+        capture_slow_query(event, notification.duration, payload)
+      end
 
-        duration_ms = notification.duration
+      def self.track_query_metrics(event, duration_ms)
         event.increment(:db_query_count)
         event.increment(:db_total_time_ms, duration_ms.round(2))
+      end
 
+      def self.capture_slow_query(event, duration_ms, payload)
         threshold = CanonicalLog.configuration.slow_query_threshold_ms
         return unless duration_ms >= threshold
 
+        sql = resolve_sql(payload[:sql])
         event.append(:slow_queries, {
-                       sql: payload[:sql],
-                       duration_ms: duration_ms.round(2),
-                       name: payload[:name]
-                     })
+          sql: sql,
+          duration_ms: duration_ms.round(2),
+          name: payload[:name],
+        })
+      end
+
+      def self.resolve_sql(raw_sql)
+        CanonicalLog.configuration.filter_sql_literals ? SqlSanitizer.sanitize(raw_sql) : raw_sql
       end
     end
   end

data/lib/canonical_log/subscribers/active_support_cache.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CanonicalLog
+  module Subscribers
+    module ActiveSupportCache
+      EVENTS = [
+        'cache_read.active_support',
+        'cache_write.active_support',
+        'cache_fetch_hit.active_support',
+      ].freeze
+
+      def self.subscribe!
+        EVENTS.each do |event_name|
+          ActiveSupport::Notifications.subscribe(event_name) do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle(event)
+          end
+        end
+      end
+
+      def self.handle(notification)
+        return unless CanonicalLog.configuration.enabled
+
+        event = Context.current
+        return unless event
+
+        event.increment(:cache_total_time_ms, notification.duration.round(2))
+        track_operation(event, notification)
+      end
+
+      def self.track_operation(event, notification)
+        case notification.name
+        when 'cache_read.active_support'
+          event.increment(:cache_read_count)
+          event.increment(notification.payload[:hit] ? :cache_hit_count : :cache_miss_count)
+        when 'cache_write.active_support'
+          event.increment(:cache_write_count)
+        when 'cache_fetch_hit.active_support'
+          event.increment(:cache_read_count)
+          event.increment(:cache_hit_count)
+        end
+      end
+      private_class_method :track_operation
+    end
+  end
+end

data/lib/canonical_log/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CanonicalLog
-  VERSION = '0.1.2'
+  VERSION = '1.0.0'
 end

data/lib/canonical_log.rb

@@ -7,13 +7,21 @@ require_relative 'canonical_log/configuration'
 require_relative 'canonical_log/sampling'
 require_relative 'canonical_log/event'
 require_relative 'canonical_log/context'
+require_relative 'canonical_log/emitter'
+require_relative 'canonical_log/sql_sanitizer'
 require_relative 'canonical_log/middleware'
 require_relative 'canonical_log/sinks/base'
 require_relative 'canonical_log/sinks/stdout'
+require_relative 'canonical_log/sinks/null'
 require_relative 'canonical_log/sinks/rails_logger'
 require_relative 'canonical_log/subscribers/action_controller'
 require_relative 'canonical_log/subscribers/active_record'
+require_relative 'canonical_log/subscribers/active_support_cache'
+require_relative 'canonical_log/formatters/pretty'
+require_relative 'canonical_log/formatters/logfmt'
+require_relative 'canonical_log/rails_log_suppressor'
 require_relative 'canonical_log/integrations/error_enrichment'
+require_relative 'canonical_log/subscribers/active_job' if defined?(ActiveJob)
 require_relative 'canonical_log/integrations/sidekiq' if defined?(Sidekiq)
 
 require_relative 'canonical_log/railtie' if defined?(Rails::Railtie)

data/lib/generators/canonical_log/templates/canonical_log.rb

@@ -1,35 +1,62 @@
 # frozen_string_literal: true
 
 CanonicalLog.configure do |config|
-  # Sinks determine where the canonical log line is written.
-  # :auto uses RailsLogger in development, Stdout in production.
+  # Master on/off switch. Defaults to true in production, false otherwise.
+  config.enabled = Rails.env.production?
+
+  # Silence Rails' built-in ActionController/ActionView log output.
+  config.suppress_rails_logging = false
+
+  # Shortcut: enable colorized, indented JSON output (sets format to :pretty).
+  config.pretty = Rails.env.development?
+
+  # Output format: :json (default), :pretty (colorized JSON), :logfmt (key=value).
+  # config.format = :json
+
+  # Where to write log lines. :auto sends JSON to $stdout.
   # config.sinks = :auto
-  # config.sinks = [CanonicalLog::Sinks::Stdout.new]
-  # config.sinks = [CanonicalLog::Sinks::RailsLogger.new]
 
-  # Parameter keys to filter from log output (replaced with [FILTERED]).
+  # Parameter keys replaced with [FILTERED] in params and query strings.
   # config.param_filter_keys = %w[password password_confirmation token secret]
 
-  # SQL queries slower than this threshold (in ms) are captured individually.
+  # Replace literal values in SQL captured as slow queries.
+  # config.filter_sql_literals = true
+
+  # Filter sensitive params from the query_string field.
+  # config.filter_query_string = true
+
+  # SQL queries slower than this (ms) are captured in slow_queries.
   # config.slow_query_threshold_ms = 100.0
 
-  # Proc to extract user context from the controller notification.
-  # Receives an ActiveSupport::Notifications::Event and should return a Hash.
-  # config.user_context = ->(notification) {
-  #   controller = notification.payload[:headers]&.env&.dig("action_controller.instance")
-  #   if controller&.respond_to?(:current_user) && controller.current_user
-  #     { user_id: controller.current_user.id }
-  #   else
-  #     {}
-  #   end
+  # Requests slower than this (ms) are always logged, even when sampled out.
+  # config.slow_request_threshold_ms = 2000.0
+
+  # Fraction of requests to log (1.0 = all). Errors and slow requests are always kept.
+  # config.sample_rate = 1.0
+
+  # Custom sampling: ->(event_hash, config) { true/false }. Overrides sample_rate.
+  # config.sampling = nil
+
+  # Number of backtrace lines in structured errors (0 to disable).
+  # config.error_backtrace_lines = 5
+
+  # Custom log level: ->(event_hash) { :info/:warn/:error }. Default: 5xx->error, 4xx->warn.
+  # config.log_level_resolver = nil
+
+  # Static fields merged into every event.
+  # config.default_fields = {}
+
+  # Extract user context from Rack env. Without this, Warden/Devise is auto-detected.
+  # config.user_context = ->(env) {
+  #   user = env["warden"]&.user
+  #   user ? { user_id: user.id } : {}
   # }
 
-  # Hook called with the Event just before it is serialized and emitted.
+  # Hook called with the Event just before emission.
   # config.before_emit = ->(event) {
   #   event.set(:app_version, ENV["APP_VERSION"])
   # }
 
-  # Paths to ignore (no canonical log line will be emitted).
-  # Supports strings (prefix match) and regexps.
+  # Paths to skip entirely. Strings match by prefix, Regexps by pattern.
   # config.ignored_paths = ["/health", "/assets", %r{\A/packs}]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canonical_log
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Krzysztof Duda
@@ -50,17 +50,25 @@ files:
 - lib/canonical_log.rb
 - lib/canonical_log/configuration.rb
 - lib/canonical_log/context.rb
+- lib/canonical_log/emitter.rb
 - lib/canonical_log/event.rb
+- lib/canonical_log/formatters/logfmt.rb
+- lib/canonical_log/formatters/pretty.rb
 - lib/canonical_log/integrations/error_enrichment.rb
 - lib/canonical_log/integrations/sidekiq.rb
 - lib/canonical_log/middleware.rb
+- lib/canonical_log/rails_log_suppressor.rb
 - lib/canonical_log/railtie.rb
 - lib/canonical_log/sampling.rb
 - lib/canonical_log/sinks/base.rb
+- lib/canonical_log/sinks/null.rb
 - lib/canonical_log/sinks/rails_logger.rb
 - lib/canonical_log/sinks/stdout.rb
+- lib/canonical_log/sql_sanitizer.rb
 - lib/canonical_log/subscribers/action_controller.rb
+- lib/canonical_log/subscribers/active_job.rb
 - lib/canonical_log/subscribers/active_record.rb
+- lib/canonical_log/subscribers/active_support_cache.rb
 - lib/canonical_log/version.rb
 - lib/generators/canonical_log/install_generator.rb
 - lib/generators/canonical_log/templates/canonical_log.rb