logstruct 0.0.2 → 0.1.1

data/lib/log_struct/enums/log_field.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+# NOTE:
+# - This enum defines human‑readable field names (constants) that map to compact
+#   JSON key symbols via `serialize` (e.g., Database => :db).
+# - The enum constant names are code‑generated into
+#   `schemas/meta/log-fields.json` by `scripts/generate_structs.rb` and
+#   referenced from `schemas/meta/log-source-schema.json` to strictly validate
+#   field keys in `schemas/log_sources/*`.
+# - When adding or renaming fields here, run the generator so schema validation
+#   stays in sync.
+#
+# Use human-readable field names as the enum values and short field names for the JSON properties
+
+module LogStruct
+  class LogField < T::Enum
+    enums do
+      # Shared fields
+      Source = new(:src)
+      Event = new(:evt)
+      Timestamp = new(:ts)
+      Level = new(:lvl)
+
+      # Common fields
+      Message = new(:msg)
+      Data = new(:data)
+
+      # Request-related fields
+      Path = new(:path)
+      HttpMethod = new(:method) # property name was http_method
+      SourceIp = new(:source_ip)
+      UserAgent = new(:user_agent)
+      Referer = new(:referer)
+      RequestId = new(:request_id)
+
+      # HTTP-specific fields
+      Format = new(:format)
+      Controller = new(:controller)
+      Action = new(:action)
+      Status = new(:status)
+      # DurationMs already defined below for general metrics
+      View = new(:view)
+      Database = new(:db)
+      Params = new(:params)
+
+      # Security-specific fields
+      BlockedHost = new(:blocked_host)
+      BlockedHosts = new(:blocked_hosts)
+      ClientIp = new(:client_ip)
+      XForwardedFor = new(:x_forwarded_for)
+
+      # Email-specific fields
+      To = new(:to)
+      From = new(:from)
+      Subject = new(:subject)
+
+      # Error fields
+      ErrClass = new(:err_class)
+      Backtrace = new(:backtrace)
+
+      # Job-specific fields
+      JobId = new(:job_id)
+      JobClass = new(:job_class)
+      QueueName = new(:queue_name)
+      Arguments = new(:arguments)
+      RetryCount = new(:retry_count)
+      Retries = new(:retries)
+      Attempt = new(:attempt)
+      Executions = new(:executions)
+      ExceptionExecutions = new(:exception_executions)
+      ProviderJobId = new(:provider_job_id)
+      ScheduledAt = new(:scheduled_at)
+      StartedAt = new(:started_at)
+      FinishedAt = new(:finished_at)
+      DurationMs = new(:duration_ms)
+      WaitMs = new(:wait_ms)
+      # Deprecated: ExecutionTime/WaitTime/RunTime
+      ExecutionTime = new(:execution_time)
+      WaitTime = new(:wait_time)
+      RunTime = new(:run_time)
+      Priority = new(:priority)
+      CronKey = new(:cron_key)
+      ErrorMessage = new(:error_message)
+
+      # Dotenv fields
+      File = new(:file)
+      Vars = new(:vars)
+      Snapshot = new(:snapshot)
+
+      # Sidekiq-specific fields
+      ProcessId = new(:pid)
+      ThreadId = new(:tid)
+      Context = new(:ctx)
+
+      # Storage-specific fields (ActiveStorage)
+      Checksum = new(:checksum)
+      Exist = new(:exist)
+      Url = new(:url)
+      Prefix = new(:prefix)
+      Range = new(:range)
+
+      # Storage-specific fields (Shrine)
+      Storage = new(:storage)
+      Operation = new(:op)
+      FileId = new(:file_id)
+      Filename = new(:filename)
+      MimeType = new(:mime_type)
+      Size = new(:size)
+      Metadata = new(:metadata)
+      Location = new(:location)
+      UploadOptions = new(:upload_opts)
+      DownloadOptions = new(:download_opts)
+      Options = new(:opts)
+      Uploader = new(:uploader)
+
+      # CarrierWave-specific fields
+      Model = new(:model)
+      MountPoint = new(:mount_point)
+
+      # SQL-specific fields
+      Sql = new(:sql)
+      Name = new(:name)
+      RowCount = new(:row_count)
+      # Use Adapter for both AMS and SQL adapter name
+      BindParams = new(:bind_params)
+      DatabaseName = new(:db_name)
+      ConnectionPoolSize = new(:pool_size)
+      ActiveConnections = new(:active_count)
+      OperationType = new(:op_type)
+      TableNames = new(:table_names)
+
+      # ActiveModelSerializers fields
+      Serializer = new(:serializer)
+      Adapter = new(:adapter)
+      ResourceClass = new(:resource_class)
+
+      # Ahoy-specific fields
+      AhoyEvent = new(:ahoy_event)
+      Properties = new(:properties)
+
+      # Puma / server lifecycle fields
+      Mode = new(:mode)
+      PumaVersion = new(:puma_version)
+      PumaCodename = new(:puma_codename)
+      RubyVersion = new(:ruby_version)
+      MinThreads = new(:min_threads)
+      MaxThreads = new(:max_threads)
+      Environment = new(:environment)
+      ListeningAddresses = new(:listening_addresses)
+      Address = new(:addr)
+    end
+  end
+end

data/lib/log_struct/enums/source.rb

@@ -7,8 +7,9 @@ module LogStruct
     enums do
       # Error sources
       TypeChecking = new(:type_checking) # For type checking errors (Sorbet)
-      LogStruct = new(:logstruct) # Errors from LogStruct itself
       Security = new(:security) # Security-related events
+      # Errors from LogStruct. (Cannot use LogStruct here because it confuses tapioca.)
+      Internal = new(:logstruct)
 
       # Application sources
       Rails = new(:rails) # For request-related logs/errors
@@ -21,6 +22,8 @@ module LogStruct
       Shrine = new(:shrine)
       CarrierWave = new(:carrierwave)
       Sidekiq = new(:sidekiq)
+      Dotenv = new(:dotenv)
+      Puma = new(:puma)
     end
   end
 end

data/lib/log_struct/formatter.rb

@@ -62,7 +62,7 @@ module LogStruct
         # Process each key-value pair
         arg.each do |key, value|
           # Check if this key should be filtered at any depth
-          result[key] = if ParamFilters.should_filter_key?(key)
+          result[key] = if ParamFilters.should_filter_key?(key, value)
             # Filter the value
             {_filtered: ParamFilters.summarize_json_attribute(key, value)}
           else
@@ -73,13 +73,7 @@ module LogStruct
 
         result
       when Array
-        result = arg.map { |value| process_values(value, recursion_depth: recursion_depth + 1) }
-
-        # Filter large arrays, but don't truncate backtraces (arrays of strings that look like file:line)
-        if result.size > 10 && !looks_like_backtrace?(result)
-          result = result.take(10) + ["... and #{result.size - 10} more items"]
-        end
-        result
+        process_array(arg, recursion_depth: recursion_depth)
       when GlobalID::Identification
         begin
           arg.to_global_id
@@ -91,10 +85,10 @@ module LogStruct
             else
               # For non-ActiveRecord objects that failed to_global_id, try to get a string representation
               # If this also fails, we want to catch it and return the error placeholder
-              T.unsafe(arg).to_s
+              String(T.cast(arg, Object))
             end
           rescue => e
-            LogStruct.handle_exception(e, source: Source::LogStruct)
+            LogStruct.handle_exception(e, source: Source::Internal)
             "[GLOBALID_ERROR]"
           end
         end
@@ -115,7 +109,7 @@ module LogStruct
         value_type: arg.class.name,
         recursion_depth: recursion_depth
       }
-      LogStruct.handle_exception(e, source: Source::LogStruct, context: context)
+      LogStruct.handle_exception(e, source: Source::Internal, context: context)
       arg
     end
 
@@ -166,7 +160,7 @@ module LogStruct
               object_class: log_value.class.name,
               object_inspect: log_value.inspect.truncate(100)
             }
-            LogStruct.handle_exception(e, source: Source::LogStruct, context: context)
+            LogStruct.handle_exception(e, source: Source::Internal, context: context)
 
             # Fall back to the string representation to ensure we continue processing
             log_value.to_s
@@ -207,17 +201,35 @@ module LogStruct
       "#{data.to_json}\n"
     end
 
+    sig { params(array: T::Array[T.untyped], recursion_depth: Integer).returns(T::Array[T.untyped]) }
+    def process_array(array, recursion_depth:)
+      return [] if array.empty?
+
+      if looks_like_backtrace_array?(array)
+        array.map { |value| process_values(value, recursion_depth: recursion_depth + 1) }
+      else
+        processed = []
+        array.each_with_index do |value, index|
+          break if index >= 10
+
+          processed << process_values(value, recursion_depth: recursion_depth + 1)
+        end
+
+        if array.size > 10
+          processed << "... and #{array.size - 10} more items"
+        end
+
+        processed
+      end
+    end
+
     # Check if an array looks like a backtrace (array of strings with file:line pattern)
     sig { params(array: T::Array[T.untyped]).returns(T::Boolean) }
-    def looks_like_backtrace?(array)
-      return false if array.empty?
-
-      # Check if most elements look like backtrace lines (file.rb:123 or similar patterns)
+    def looks_like_backtrace_array?(array)
       backtrace_like_count = array.first(5).count do |element|
         element.is_a?(String) && element.match?(/\A[^:\s]+:\d+/)
       end
 
-      # If at least 3 out of the first 5 elements look like backtrace lines, treat as backtrace
       backtrace_like_count >= 3
     end
   end

data/lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -75,11 +75,7 @@ module LogStruct
           }
 
           # Create the structured exception log
-          exception_data = Log::Error.from_exception(
-            Source::Mailer,
-            error,
-            context
-          )
+          exception_data = Log.from_exception(Source::Mailer, error, context)
 
           # Log the structured error
           LogStruct.error(exception_data)
@@ -123,11 +119,7 @@ module LogStruct
             }
 
             # Create an exception log for structured logging
-            exception_data = Log::Error.from_exception(
-              Source::Mailer,
-              error,
-              context
-            )
+            exception_data = Log.from_exception(Source::Mailer, error, context)
 
             # Log the exception with structured data
             LogStruct.error(exception_data)
@@ -144,7 +136,7 @@ module LogStruct
         sig { params(error: StandardError).void }
         def log_notification_event(error)
           # Create an error log data object
-          exception_data = Log::Error.from_exception(
+          exception_data = Log.from_exception(
             Source::Mailer,
             error,
             {

data/lib/log_struct/integrations/action_mailer/event_logging.rb

@@ -36,11 +36,7 @@ module LogStruct
         private
 
         # Log a mailer event with the given event type
-        sig do
-          params(event_type: Log::ActionMailer::ActionMailerEvent,
-            level: Symbol,
-            additional_data: T::Hash[Symbol, T.untyped]).returns(T.untyped)
-        end
+        sig { params(event_type: LogStruct::Event, level: Symbol, additional_data: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
         def log_mailer_event(event_type, level = :info, additional_data = {})
           # Get message (self refers to the mailer instance)
           mailer_message = message if respond_to?(:message)
@@ -62,16 +58,30 @@ module LogStruct
           from = mailer_message&.from&.first
           subject = mailer_message&.subject
 
-          # Create a structured log entry
-          log_data = Log::ActionMailer.new(
-            event: event_type,
+          base_fields = Log::ActionMailer::BaseFields.new(
             to: to,
             from: from,
-            subject: subject,
-            additional_data: data
+            subject: subject
           )
-          LogStruct.info(log_data)
-          log_data
+
+          log = case event_type
+          when Event::Delivery
+            Log::ActionMailer::Delivery.new(
+              **base_fields.to_kwargs,
+              additional_data: data,
+              timestamp: Time.now
+            )
+          when Event::Delivered
+            Log::ActionMailer::Delivered.new(
+              **base_fields.to_kwargs,
+              additional_data: data,
+              timestamp: Time.now
+            )
+          else
+            return
+          end
+          LogStruct.info(log)
+          log
         end
 
         # Extract message ID from the mailer

data/lib/log_struct/integrations/active_job/log_subscriber.rb

@@ -13,84 +13,88 @@ module LogStruct
       class LogSubscriber < ::ActiveJob::LogSubscriber
         extend T::Sig
 
-        sig { params(event: T.untyped).void }
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue(event)
-          job = event.payload[:job]
-          log_job_event(Event::Enqueue, job, event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          ts = event.time ? Time.at(event.time) : Time.now
+          base_fields = build_base_fields(job)
+          logger.info(Log::ActiveJob::Enqueue.new(
+            **base_fields.to_kwargs,
+            timestamp: ts
+          ))
         end
 
-        sig { params(event: T.untyped).void }
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue_at(event)
-          job = event.payload[:job]
-          log_job_event(Event::Schedule, job, event, scheduled_at: job.scheduled_at)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          ts = event.time ? Time.at(event.time) : Time.now
+          base_fields = build_base_fields(job)
+          logger.info(Log::ActiveJob::Schedule.new(
+            **base_fields.to_kwargs,
+            scheduled_at: job.scheduled_at,
+            timestamp: ts
+          ))
         end
 
-        sig { params(event: T.untyped).void }
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def perform(event)
-          job = event.payload[:job]
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
           exception = event.payload[:exception_object]
 
           if exception
             # Log the exception with the job context
             log_exception(exception, job, event)
           else
-            log_job_event(Event::Finish, job, event, duration: event.duration.round(2))
+            start_float = event.time
+            end_float = event.end
+            ts = start_float ? Time.at(start_float) : Time.now
+            finished_at = end_float ? Time.at(end_float) : Time.now
+            base_fields = build_base_fields(job)
+            logger.info(Log::ActiveJob::Finish.new(
+              **base_fields.to_kwargs,
+              duration_ms: event.duration.to_f,
+              finished_at: finished_at,
+              timestamp: ts
+            ))
           end
         end
 
-        sig { params(event: T.untyped).void }
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def perform_start(event)
-          job = event.payload[:job]
-          log_job_event(Event::Start, job, event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          ts = event.time ? Time.at(event.time) : Time.now
+          started_at = ts
+          attempt = job.executions
+          base_fields = build_base_fields(job)
+          logger.info(Log::ActiveJob::Start.new(
+            **base_fields.to_kwargs,
+            started_at: started_at,
+            attempt: attempt,
+            timestamp: ts
+          ))
         end
 
         private
 
-        sig { params(event_type: T.any(Event::Enqueue, Event::Schedule, Event::Start, Event::Finish), job: T.untyped, _event: T.untyped, additional_data: T::Hash[Symbol, T.untyped]).void }
-        def log_job_event(event_type, job, _event, additional_data = {})
-          # Create structured log data
-          log_data = Log::ActiveJob.new(
-            event: event_type,
+        sig { params(job: ::ActiveJob::Base).returns(Log::ActiveJob::BaseFields) }
+        def build_base_fields(job)
+          Log::ActiveJob::BaseFields.new(
             job_id: job.job_id,
             job_class: job.class.to_s,
             queue_name: job.queue_name,
-            duration: additional_data[:duration],
-            # Add arguments if the job class allows it
-            arguments: job.class.log_arguments? ? job.arguments : nil,
-            # Store additional data in the data hash
-            additional_data: {
-              executions: job.executions,
-              scheduled_at: additional_data[:scheduled_at],
-              provider_job_id: job.provider_job_id
-            }.compact
+            executions: job.executions,
+            provider_job_id: job.provider_job_id,
+            arguments: ((job.class.respond_to?(:log_arguments?) && job.class.log_arguments?) ? job.arguments : nil)
           )
-
-          # Use Rails logger with our structured formatter
-          logger.info(log_data)
         end
 
-        sig { params(exception: StandardError, job: T.untyped, _event: T.untyped).void }
+        sig { params(exception: StandardError, job: ::ActiveJob::Base, _event: ::ActiveSupport::Notifications::Event).void }
         def log_exception(exception, job, _event)
-          # Create job context data for the exception
-          job_context = {
-            job_id: job.job_id,
-            job_class: job.class.to_s,
-            queue_name: job.queue_name,
-            executions: job.executions,
-            provider_job_id: job.provider_job_id
-          }
+          base_fields = build_base_fields(job)
+          job_context = base_fields.to_kwargs
 
-          # Add arguments if the job class allows it
-          job_context[:arguments] = job.arguments if job.class.log_arguments?
-
-          # Create exception log with job source and context
-          log_data = Log::Error.from_exception(
-            Source::Job,
-            exception,
-            job_context
-          )
+          log_data = Log.from_exception(Source::Job, exception, job_context)
 
-          # Use Rails logger with our structured formatter
           logger.error(log_data)
         end
 

data/lib/log_struct/integrations/active_model_serializers.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module LogStruct
+  module Integrations
+    # ActiveModelSerializers integration. Subscribes to AMS notifications and
+    # emits structured logs with serializer/adapter/duration details.
+    module ActiveModelSerializers
+      extend T::Sig
+
+      sig { params(config: LogStruct::Configuration).returns(T.nilable(TrueClass)) }
+      def self.setup(config)
+        return nil unless defined?(::ActiveSupport::Notifications)
+
+        # Only activate if AMS appears to be present
+        return nil unless defined?(::ActiveModelSerializers)
+
+        # Subscribe to common AMS notification names; keep broad but specific
+        pattern = /\.active_model_serializers\z/
+
+        ::ActiveSupport::Notifications.subscribe(pattern) do |_name, started, finished, _unique_id, payload|
+          # started/finished are Time; convert to ms
+          duration_ms = ((finished - started) * 1000.0).round(3)
+
+          serializer = payload[:serializer] || payload[:serializer_class]
+          adapter = payload[:adapter]
+          resource = payload[:resource] || payload[:object]
+
+          LogStruct.info(
+            LogStruct::Log::ActiveModelSerializers.new(
+              message: "ams.render",
+              serializer: serializer&.to_s,
+              adapter: adapter&.to_s,
+              resource_class: resource&.class&.name,
+              duration_ms: duration_ms,
+              timestamp: started
+            )
+          )
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Rails, context: {integration: :active_model_serializers})
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/active_record.rb

@@ -40,12 +40,33 @@ module LogStruct
       extend T::Sig
       extend IntegrationInterface
 
+      # Track subscription state keyed to the current Notifications.notifier instance
+      State = ::Struct.new(:subscribed, :notifier_id)
+      STATE = T.let(State.new(false, nil), State)
+
       # Set up SQL query logging integration
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
         return nil unless config.integrations.enable_sql_logging
         return nil unless defined?(::ActiveRecord::Base)
 
+        # Detach Rails' default ActiveRecord log subscriber to prevent
+        # duplicate/unstructured SQL debug output when LogStruct SQL logging
+        # is enabled. We still receive notifications via ActiveSupport.
+        if defined?(::ActiveRecord::LogSubscriber)
+          begin
+            ::ActiveRecord::LogSubscriber.detach_from(:active_record)
+          rescue => e
+            LogStruct.handle_exception(e, source: LogStruct::Source::Internal)
+          end
+        end
+
+        # Disable verbose query logs ("↳ caller") since LogStruct provides
+        # structured context and these lines are noisy/unstructured.
+        if ::ActiveRecord::Base.respond_to?(:verbose_query_logs=)
+          T.unsafe(::ActiveRecord::Base).verbose_query_logs = false
+        end
+
         subscribe_to_sql_notifications
         true
       end
@@ -55,11 +76,20 @@ module LogStruct
       # Subscribe to ActiveRecord's sql.active_record notifications
       sig { void }
       def self.subscribe_to_sql_notifications
+        # Avoid duplicate subscriptions; re-subscribe if the notifier was reset
+        notifier = ::ActiveSupport::Notifications.notifier
+        current_id = notifier&.object_id
+        if STATE.subscribed && STATE.notifier_id == current_id
+          return
+        end
+
         ::ActiveSupport::Notifications.subscribe("sql.active_record") do |name, start, finish, id, payload|
           handle_sql_event(name, start, finish, id, payload)
         rescue => error
-          LogStruct.handle_exception(error, source: LogStruct::Source::LogStruct)
+          LogStruct.handle_exception(error, source: LogStruct::Source::Internal)
         end
+        STATE.subscribed = true
+        STATE.notifier_id = current_id
       end
 
       # Process SQL notification event and create structured log
@@ -68,12 +98,12 @@ module LogStruct
         # Skip schema queries and Rails internal queries
         return if skip_query?(payload)
 
-        duration = ((finish - start) * 1000.0).round(2)
+        duration_ms = ((finish - start) * 1000.0).round(2)
 
         # Skip fast queries if threshold is configured
         config = LogStruct.config
         if config.integrations.sql_slow_query_threshold&.positive?
-          return if duration < config.integrations.sql_slow_query_threshold
+          return if duration_ms < config.integrations.sql_slow_query_threshold
         end
 
         sql_log = Log::SQL.new(
@@ -82,9 +112,9 @@ module LogStruct
           event: Event::Database,
           sql: payload[:sql]&.strip || "",
           name: payload[:name] || "SQL Query",
-          duration: duration,
+          duration_ms: duration_ms,
           row_count: extract_row_count(payload),
-          connection_adapter: extract_adapter_name(payload),
+          adapter: extract_adapter_name(payload),
           bind_params: extract_and_filter_binds(payload),
           database_name: extract_database_name(payload),
           connection_pool_size: extract_pool_size(payload),