heaps more work

Author: ndbroadbent

lib/log_struct/concerns/error_handling.rb

@@ -40,7 +40,6 @@ def log_exception(error, source:, context: nil)
           # Create structured log entry
           exception_log = Log::Exception.from_exception(
             source,
-            LogEvent::Error,
             error,
             context || {}
           )

lib/log_struct/json_formatter.rb lib/log_struct/formatter.rblib/log_struct/json_formatter.rb renamed to lib/log_struct/formatter.rb

@@ -13,7 +13,7 @@
 require_relative "multi_error_reporter"
 
 module LogStruct
-  class JSONFormatter < Logger::Formatter
+  class Formatter < ::Logger::Formatter
     extend T::Sig
 
     # Add current_tags method to support ActiveSupport::TaggedLogging
@@ -23,7 +23,7 @@ def current_tags
     end
 
     # Add tagged method to support ActiveSupport::TaggedLogging
-    sig { params(tags: T::Array[String], blk: T.proc.params(formatter: JSONFormatter).void).returns(T.untyped) }
+    sig { params(tags: T::Array[String], blk: T.proc.params(formatter: Formatter).void).returns(T.untyped) }
     def tagged(*tags, &blk)
       new_tags = tags.flatten
       current_tags.concat(new_tags) if new_tags.any?
@@ -92,7 +92,7 @@ def process_values(arg, recursion_depth: 0)
             "[GLOBALID_ERROR]"
           end
         end
-      when LogSource, LogEvent
+      when Source, LogEvent
         arg.serialize
       when String
         scrub_string(arg)
@@ -119,8 +119,8 @@ def call(severity, time, progname, log_value)
       else
         # Create a Plain struct with the message and then serialize it
         plain = Log::Plain.new(
-          msg: log_value.to_s,
-          ts: time
+          message: log_value.to_s,
+          timestamp: time
         )
         plain.serialize
       end
@@ -133,7 +133,7 @@ def call(severity, time, progname, log_value)
       data[:evt] ||= "log"
       data[:ts] ||= time.iso8601(3)
       data[:lvl] = severity.downcase
-      data[:progname] = progname if progname.present?
+      data[:prog] = progname if progname.present?
 
       generate_json(data)
     end

lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -80,7 +80,6 @@ def handle_error_notifications(error, notify, report, reraise)
             # Create an exception log for structured logging
             exception_data = Log::Exception.from_exception(
               Source::Mailer,
-              LogEvent::Error,
               error,
               context
             )
@@ -102,7 +101,6 @@ def log_notification_event(error)
           # Create an error log data object
           exception_data = Log::Exception.from_exception(
             Source::Mailer,
-            LogEvent::Error,
             error,
             {
               mailer: self.class,

lib/log_struct/integrations/action_mailer/event_logging.rb

@@ -24,20 +24,20 @@ module EventLogging
         # Log when an email is about to be delivered
         sig { void }
         def log_email_delivery
-          log_mailer_event(LogStruct::LogEvent::Delivery)
+          log_mailer_event(LogEvent::Delivery)
         end
 
         # Log when an email is delivered
         sig { void }
         def log_email_delivered
-          log_mailer_event(LogStruct::LogEvent::Delivered)
+          log_mailer_event(LogEvent::Delivered)
         end
 
         private
 
         # Log a mailer event with the given event type
         sig do
-          params(event_type: LogStruct::LogEvent,
+          params(event_type: LogEvent,
             level: Symbol,
             additional_data: T::Hash[Symbol, T.untyped]).returns(T.untyped)
         end
@@ -62,21 +62,21 @@ def log_mailer_event(event_type, level = :info, additional_data = {})
           from = mailer_message&.from&.first
           subject = mailer_message&.subject
 
-          # Map Rails log level to LogStruct::LogLevel
+          # Map Rails log level to LogLevel
           log_level = case level
           when :error, :fatal
-            LogStruct::LogLevel::Error
+            LogLevel::Error
           when :warn
-            LogStruct::LogLevel::Warn
+            LogLevel::Warn
           when :debug
-            LogStruct::LogLevel::Debug
+            LogLevel::Debug
           else
-            LogStruct::LogLevel::Info
+            LogLevel::Info
           end
 
           # Create a structured log entry
-          log_data = LogStruct::Log::Email.new(
-            evt: event_type,
+          log_data = Log::Email.new(
+            event: event_type,
             lvl: log_level,
             to: to,
             from: from,

lib/log_struct/integrations/action_mailer/logger.rb

@@ -13,8 +13,8 @@ module Logger
         end
         def self.build_base_log_data(mailer, event_type)
           log_data = {
-            src: "mailer",
-            evt: event_type,
+            source: "mailer",
+            event: event_type,
             ts: Time.now.iso8601(3),
             message_id: extract_message_id(mailer),
             mailer_class: mailer.class.to_s,
@@ -45,10 +45,9 @@ def self.log_structured_error(mailer, error, message)
 
           # Create an exception log with proper structured data
           exception_data = Log::Exception.from_exception(
-            LogSource::Mailer,
-            LogEvent::Error,
+            Source::Mailer,
             error,
-            log_data.merge(msg: message)
+            log_data.merge(message: message)
           )
 
           log_to_rails(exception_data, :error)

lib/log_struct/integrations/active_job/log_subscriber.rb

@@ -13,12 +13,12 @@ module ActiveJob
       class LogSubscriber < ::ActiveJob::LogSubscriber
         def enqueue(event)
           job = event.payload[:job]
-          log_job_event(LogEvent::JobExecution, job, event)
+          log_job_event(LogEvent::Enqueue, job, event)
         end
 
         def enqueue_at(event)
           job = event.payload[:job]
-          log_job_event(LogEvent::JobExecution, job, event, scheduled_at: job.scheduled_at)
+          log_job_event(LogEvent::Schedule, job, event, scheduled_at: job.scheduled_at)
         end
 
         def perform(event)
@@ -29,21 +29,21 @@ def perform(event)
             # Log the exception with the job context
             log_exception(exception, job, event)
           else
-            log_job_event(LogEvent::JobExecution, job, event, duration: event.duration.round(2))
+            log_job_event(LogEvent::Finish, job, event, duration: event.duration.round(2))
           end
         end
 
         def perform_start(event)
           job = event.payload[:job]
-          log_job_event(LogEvent::JobExecution, job, event)
+          log_job_event(LogEvent::Start, job, event)
         end
 
         private
 
         def log_job_event(event_type, job, _event, additional_data = {})
           # Create structured log data
           log_data = Log::Job.new(
-            evt: event_type,
+            event: event_type,
             job_id: job.job_id,
             job_class: job.class.to_s,
             queue_name: job.queue_name,
@@ -77,8 +77,7 @@ def log_exception(exception, job, _event)
 
           # Create exception log with job source and context
           log_data = Log::Exception.from_exception(
-            LogSource::Job,
-            LogEvent::Error,
+            Source::Job,
             exception,
             job_context
           )

lib/log_struct/integrations/active_storage.rb

@@ -43,8 +43,8 @@ def process_active_storage_event(event)
 
           # Create structured log data
           log_data = Log::Storage.new(
-            src: LogSource::Storage,
-            evt: event_type,
+            source: Source::Storage,
+            event: event_type,
             operation: operation,
             storage: service,
             file_id: payload[:key],

lib/log_struct/integrations/carrierwave.rb

@@ -73,8 +73,8 @@ def log_operation(operation, file_info, duration)
 
           # Create structured log data
           log_data = Log::CarrierWave.new(
-            src: LogSource::CarrierWave,
-            evt: event_type,
+            source: Source::CarrierWave,
+            event: event_type,
             operation: operation.to_s,
             storage: storage.to_s,
             file_id: identifier,

lib/log_struct/integrations/host_authorization.rb

@@ -21,9 +21,9 @@ def setup
             blocked_hosts = env["action_dispatch.blocked_hosts"]
 
             # Create a structured security log entry
-            security_log = LogStruct::Log::Security.new(
-              sec_evt: LogSecurityEvent::BlockedHost,
-              msg: "Blocked host detected: #{request.host}",
+            security_log = Log::Security.new(
+              sec_event: LogSecurityEvent::BlockedHost,
+              message: "Blocked host detected: #{request.host}",
               blocked_host: request.host,
               blocked_hosts: blocked_hosts,
               request_id: request.request_id,

lib/log_struct/integrations/lograge.rb

@@ -21,13 +21,13 @@ def setup
           ::Rails.application.configure do
             config.lograge.enabled = true
             # Use a raw formatter that just returns the log struct.
-            # The struct is converted to JSON by our JSONFormatter (after filtering, etc.)
+            # The struct is converted to JSON by our Formatter (after filtering, etc.)
             config.lograge.formatter = T.let(
               lambda do |data|
                 # Convert the data hash to a Log::Request struct
                 Log::Request.new(
-                  src: LogSource::Rails,
-                  evt: LogEvent::Request,
+                  source: Source::Rails,
+                  event: LogEvent::Request,
                   ts: T.cast(Time.now, Time),
                   http_method: data[:method],
                   path: data[:path],
@@ -61,7 +61,7 @@ def lograge_default_options(event)
           ).compact
 
           # We'll set these in the formatter
-          # options[:src] = LogSource::Rails
+          # options[:src] = Source::Rails
           # options[:evt] = LogEvent::Request
 
           if event.payload[:params].present?