fix jscpd duplication

Author: ndbroadbent

.cspell/project-words.txt

@@ -44,6 +44,7 @@ mswin
 nilability
 nilable
 nonblock
+nonblocking
 optparse
 parseable
 pentester

lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -150,38 +150,8 @@ def handle_error_notifications(error, notify, report, reraise)
 
           # Report to error reporting service if requested
           if report
-            # Get message if available
-            mailer_message = respond_to?(:message) ? message : nil
-
-            # Prepare universal mailer fields
-            message_data = {}
-            MetadataCollection.add_message_metadata(self, message_data)
-
-            # Prepare app-specific context data
             context_data = {recipients: recipients(error)}
-            MetadataCollection.add_context_metadata(self, context_data)
-
-            # Extract email fields
-            to = mailer_message&.to
-            from = mailer_message&.from&.first
-            subject = mailer_message&.subject
-            message_id = extract_message_id_from_mailer(self)
-
-            # Create ActionMailer-specific error struct
-            exception_data = Log::ActionMailer::Error.new(
-              to: to,
-              from: from,
-              subject: subject,
-              message_id: message_id,
-              mailer_class: self.class.to_s,
-              mailer_action: respond_to?(:action_name) ? action_name&.to_s : nil,
-              attachment_count: message_data[:attachment_count],
-              error_class: error.class,
-              message: error.message,
-              backtrace: error.backtrace,
-              additional_data: context_data.presence,
-              timestamp: Time.now
-            )
+            exception_data = build_exception_data(error, Level::Error, context_data)
 
             # Log the exception with structured data
             LogStruct.error(exception_data)
@@ -202,29 +172,32 @@ def handle_error_notifications(error, notify, report, reraise)
         # Log a notification event that can be picked up by external systems
         sig { params(error: StandardError).void }
         def log_notification_event(error)
-          # Get message if available
-          mailer_message = respond_to?(:message) ? message : nil
-
-          # Prepare universal mailer fields
-          message_data = {}
-          MetadataCollection.add_message_metadata(self, message_data)
-
-          # Prepare app-specific context data
           context_data = {
             mailer: self.class.to_s,
             action: action_name&.to_s,
             recipients: recipients(error)
           }
+          exception_data = build_exception_data(error, Level::Info, context_data)
+
+          # Log the error at info level since it's not a critical error
+          LogStruct.info(exception_data)
+        end
+
+        sig { params(error: StandardError, level: Level, context_data: T::Hash[Symbol, T.untyped]).returns(Log::ActionMailer::Error) }
+        def build_exception_data(error, level, context_data)
+          mailer_message = respond_to?(:message) ? message : nil
+
+          message_data = {}
+          MetadataCollection.add_message_metadata(self, message_data)
+
           MetadataCollection.add_context_metadata(self, context_data)
 
-          # Extract email fields
           to = mailer_message&.to
           from = mailer_message&.from&.first
           subject = mailer_message&.subject
           message_id = extract_message_id_from_mailer(self)
 
-          # Create ActionMailer-specific error struct
-          exception_data = Log::ActionMailer::Error.new(
+          Log::ActionMailer::Error.new(
             to: to,
             from: from,
             subject: subject,
@@ -237,11 +210,8 @@ def log_notification_event(error)
             backtrace: error.backtrace,
             additional_data: context_data.presence,
             timestamp: Time.now,
-            level: Level::Info
+            level: level
           )
-
-          # Log the error at info level since it's not a critical error
-          LogStruct.info(exception_data)
         end
 
         sig { params(error: StandardError).returns(String) }

lib/log_struct/integrations/dotenv.rb

@@ -34,6 +34,20 @@ def self.setup(config)
       class << self
         extend T::Sig
 
+        sig { params(env: T.untyped).returns(String) }
+        def relative_env_path(env)
+          abs = env.filename
+          begin
+            if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+              Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
+            else
+              abs
+            end
+          rescue
+            abs
+          end
+        end
+
         sig { void }
         def subscribe!
           # Guard against double subscription
@@ -47,16 +61,7 @@ def subscribe!
             LogStruct::Log::Dotenv.new
             event = ::ActiveSupport::Notifications::Event.new(*args)
             env = event.payload[:env]
-            abs = env.filename
-            file = begin
-              if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
-                Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
-              else
-                abs
-              end
-            rescue
-              abs
-            end
+            file = relative_env_path(env)
 
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.info(Log::Dotenv::Load.new(file: file, timestamp: ts))
@@ -134,16 +139,7 @@ def self.setup_boot
         instrumenter.subscribe("load.dotenv") do |*args|
           event = ::ActiveSupport::Notifications::Event.new(*args)
           env = event.payload[:env]
-          abs = env.filename
-          file = begin
-            if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
-              Pathname.new(abs).relative_path_from(Pathname.new(::Rails.root.to_s)).to_s
-            else
-              abs
-            end
-          rescue
-            abs
-          end
+          file = relative_env_path(env)
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Load.new(file: file, timestamp: ts))
         rescue => e

lib/log_struct/integrations/puma.rb

@@ -50,16 +50,7 @@ def setup(config)
           if ARGV.include?("server")
             # Emit deterministic boot/started events based on CLI args
             begin
-              port = T.let(nil, T.nilable(String))
-              ARGV.each_with_index do |arg, idx|
-                if arg == "-p" || arg == "--port"
-                  port = ARGV[idx + 1]
-                  break
-                elsif arg.start_with?("--port=")
-                  port = arg.split("=", 2)[1]
-                  break
-                end
-              end
+              port = port_from_argv(ARGV)
               si = T.cast(STATE[:start_info], T::Hash[Symbol, T.untyped])
               si[:pid] ||= Process.pid
               si[:environment] ||= ((defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil)
@@ -175,6 +166,18 @@ def state_reset!
           }
         end
 
+        sig { params(argv: T::Array[String]).returns(T.nilable(String)) }
+        def port_from_argv(argv)
+          argv.each_with_index do |arg, idx|
+            if arg == "-p" || arg == "--port"
+              return argv[idx + 1]
+            elsif arg.start_with?("--port=")
+              return arg.split("=", 2)[1]
+            end
+          end
+          nil
+        end
+
         sig { params(line: String).returns(T::Boolean) }
         def process_line(line)
           l = line.to_s.strip
@@ -243,16 +246,7 @@ def process_line(line)
             # Fallback: if no listening address captured yet, infer from ARGV
             if T.cast(si[:listening], T::Array[T.untyped]).empty?
               begin
-                port = T.let(nil, T.untyped)
-                ARGV.each_with_index do |arg, idx|
-                  if arg == "-p" || arg == "--port"
-                    port = ARGV[idx + 1]
-                    break
-                  elsif arg.start_with?("--port=")
-                    port = arg.split("=", 2)[1]
-                    break
-                  end
-                end
+                port = port_from_argv(ARGV)
                 if port
                   si[:listening] << "tcp://127.0.0.1:#{port}"
                 end

lib/log_struct/integrations/rack.rb

@@ -4,6 +4,7 @@
 require "rack"
 require "action_dispatch/middleware/show_exceptions"
 require_relative "rack/error_handling_middleware"
+require_relative "rack_setup"
 
 module LogStruct
   module Integrations
@@ -15,12 +16,11 @@ module Rack
       # Set up Rack middleware for structured error logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return nil unless config.enabled
-        return nil unless config.integrations.enable_rack_error_handler
+        return nil unless RackSetup.enabled?(config)
 
         # Add structured logging middleware for security violations and errors
         # Need to insert after ShowExceptions to catch IP spoofing errors
-        ::Rails.application.middleware.insert_after(
+        RackSetup.insert_after(
           ::ActionDispatch::ShowExceptions,
           Integrations::RackErrorHandler::Middleware
         )

lib/log_struct/integrations/rack_error_handler.rb

@@ -4,6 +4,7 @@
 require "rack"
 require "action_dispatch/middleware/show_exceptions"
 require_relative "rack_error_handler/middleware"
+require_relative "rack_setup"
 
 module LogStruct
   module Integrations
@@ -15,12 +16,11 @@ module RackErrorHandler
       # Set up Rack middleware for structured error logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return nil unless config.enabled
-        return nil unless config.integrations.enable_rack_error_handler
+        return nil unless RackSetup.enabled?(config)
 
         # Add structured logging middleware for security violations and errors
         # Need to insert before RemoteIp to catch IP spoofing errors it raises
-        ::Rails.application.middleware.insert_before(
+        RackSetup.insert_before(
           ::ActionDispatch::RemoteIp,
           Integrations::RackErrorHandler::Middleware
         )

lib/log_struct/integrations/rack_setup.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module RackSetup
+      extend T::Sig
+
+      sig { params(config: LogStruct::Configuration).returns(T::Boolean) }
+      def self.enabled?(config)
+        return false unless config.enabled
+        return false unless config.integrations.enable_rack_error_handler
+
+        true
+      end
+
+      sig { params(anchor: T.untyped, middleware: T.untyped).void }
+      def self.insert_after(anchor, middleware)
+        ::Rails.application.middleware.insert_after(anchor, middleware)
+      end
+
+      sig { params(anchor: T.untyped, middleware: T.untyped).void }
+      def self.insert_before(anchor, middleware)
+        ::Rails.application.middleware.insert_before(anchor, middleware)
+      end
+    end
+  end
+end

lib/log_struct/railtie.rb

@@ -46,16 +46,7 @@ class Railtie < ::Rails::Railtie
       next unless is_server
       begin
         require "log_struct/log/puma"
-        port = T.let(nil, T.nilable(String))
-        ARGV.each_with_index do |arg, idx|
-          if arg == "-p" || arg == "--port"
-            port = ARGV[idx + 1]
-            break
-          elsif arg.start_with?("--port=")
-            port = arg.split("=", 2)[1]
-            break
-          end
-        end
+        port = LogStruct::Integrations::Puma.port_from_argv(ARGV)
         started = LogStruct::Log::Puma::Start.new(
           mode: "single",
           environment: (defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil,

lib/log_struct/semantic_logger/color_formatter.rb

@@ -62,44 +62,11 @@ def initialize(color_map: nil, **args)
       def call(log, logger)
         # Handle LogStruct types specially with colorization
         if log.payload.is_a?(LogStruct::Log::Interfaces::CommonFields)
-          # Get the LogStruct formatted JSON
-          logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
-
-          # Parse and colorize it
-          begin
-            parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
-            colorized_json = colorize_json(parsed_data)
-
-            # Use SemanticLogger's prefix formatting but with our colorized content
-            prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
-              time: format_time(log.time),
-              level: format_level(log.level),
-              process: log.process_info,
-              name: format_name(log.name))
-
-            "#{prefix}#{colorized_json}\n"
-          rescue JSON::ParserError
-            # Fallback to standard formatting
-            super
-          end
+          formatted = format_logstruct_payload(log)
+          formatted if formatted
         elsif log.payload.is_a?(Hash) || log.payload.is_a?(T::Struct)
-          # Process hashes through our formatter then colorize
-          begin
-            logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
-            parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
-            colorized_json = colorize_json(parsed_data)
-
-            prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
-              time: format_time(log.time),
-              level: format_level(log.level),
-              process: log.process_info,
-              name: format_name(log.name))
-
-            "#{prefix}#{colorized_json}\n"
-          rescue JSON::ParserError
-            # Fallback to standard formatting
-            super
-          end
+          formatted = format_logstruct_payload(log)
+          formatted if formatted
         else
           # For plain messages, use SemanticLogger's default colorization
           super
@@ -139,6 +106,24 @@ def colorize_json(data)
           .gsub(": null", ": " + colorize_text("null", :nil))
       end
 
+      sig { params(log: ::SemanticLogger::Log).returns(T.nilable(String)) }
+      def format_logstruct_payload(log)
+        logstruct_json = @logstruct_formatter.call(log.level, log.time, log.name, log.payload)
+
+        parsed_data = T.let(JSON.parse(logstruct_json), T::Hash[String, T.untyped])
+        colorized_json = colorize_json(parsed_data)
+
+        prefix = format("%<time>s %<level>s [%<process>s] %<name>s -- ",
+          time: format_time(log.time),
+          level: format_level(log.level),
+          process: log.process_info,
+          name: format_name(log.name))
+
+        "#{prefix}#{colorized_json}\n"
+      rescue JSON::ParserError
+        nil
+      end
+
       # Add ANSI color codes to text
       sig { params(text: String, color_type: Symbol).returns(String) }
       def colorize_text(text, color_type)