Remove production override for coming soon flag

The coming soon page visibility is now controlled by NEXT_PUBLIC_SHOW_COMING_SOON
environment variable in all environments, not hardcoded for production.

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ndbroadbent

lib/log_struct/concerns/logging.rb

@@ -2,42 +2,64 @@
 # frozen_string_literal: true
 
 require_relative "../log"
+require_relative "../private_logger"
 
 module LogStruct
   module Concerns
-    # Concern for handling errors according to configured modes
+    # Concern for handling logging in LogStruct
     module Logging
       module ClassMethods
         extend T::Sig
 
+        # Private logger singleton
+        @private_logger = T.let(nil, T.nilable(PrivateLogger))
+
+        # Get the singleton private logger instance, optionally initializing with a specific target
+        sig { params(logdev: T.nilable(T.any(String, IO, StringIO))).returns(PrivateLogger) }
+        def private_logger(logdev = nil)
+          # Only initialize once with the first valid logdev
+          if @private_logger.nil? && !logdev.nil?
+            @private_logger = PrivateLogger.new(logdev)
+          end
+
+          # Create with stdout as fallback if no logdev specified
+          @private_logger ||= PrivateLogger.new($stdout)
+        end
+
+        # Allow internal code to set the private logger (used by Railtie)
+        sig { params(logger: PrivateLogger).void }
+        def set_private_logger(logger)
+          @private_logger = logger
+        end
+
         # Log a log struct at debug level
         sig { params(log: Log::Interfaces::CommonFields).void }
         def debug(log)
-          Rails.logger.debug(log)
+          private_logger.debug(log)
         end
 
         # Log a log struct at info level
         sig { params(log: Log::Interfaces::CommonFields).void }
         def info(log)
-          Rails.logger.info(log)
+          private_logger.info(log)
         end
 
         # Log a log struct at warn level
         sig { params(log: Log::Interfaces::CommonFields).void }
         def warn(log)
-          Rails.logger.warn(log)
+          private_logger.warn(log)
         end
 
         # Log a log struct at error level
         sig { params(log: Log::Interfaces::CommonFields).void }
         def error(log)
-          Rails.logger.error(log)
+          private_logger.error(log)
         end
 
         # Log a log struct at fatal level
         sig { params(log: Log::Interfaces::CommonFields).void }
         def fatal(log)
-          Rails.logger.fatal(log)
+          private_logger.fatal(log)
         end
       end
     end

lib/log_struct/logger.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_support/logger"
+require_relative "formatter"
+require_relative "enums/level"
+require_relative "log/interfaces/common_fields"
+
+module LogStruct
+  # Private Logger for internal LogStruct use with strict typing
+  # All logs must use LogStruct log classes with proper enums
+  class PrivateLogger < ActiveSupport::Logger
+    extend T::Sig
+
+    # Initialize with the same parameters as ActiveSupport::Logger
+    sig { params(logdev: T.any(String, IO, StringIO, NilClass), shift_age: T.nilable(Integer), shift_size: T.nilable(Integer), level: T.nilable(T.any(Integer, Symbol, String))).void }
+    def initialize(logdev = nil, shift_age = 0, shift_size = 1048576, level: nil)
+      super
+      self.formatter = LogStruct::Formatter.new
+
+      # Set level explicitly if passed
+      self.level = level if level
+    end
+
+    # Log with DEBUG level
+    sig { params(log_data: Log::Interfaces::CommonFields).returns(T.untyped) }
+    def debug(log_data)
+      add(Level::Debug, log_data)
+    end
+
+    # Log with INFO level
+    sig { params(log_data: Log::Interfaces::CommonFields).returns(T.untyped) }
+    def info(log_data)
+      add(Level::Info, log_data)
+    end
+
+    # Log with WARN level
+    sig { params(log_data: Log::Interfaces::CommonFields).returns(T.untyped) }
+    def warn(log_data)
+      add(Level::Warn, log_data)
+    end
+
+    # Log with ERROR level
+    sig { params(log_data: Log::Interfaces::CommonFields).returns(T.untyped) }
+    def error(log_data)
+      add(Level::Error, log_data)
+    end
+
+    # Log with FATAL level
+    sig { params(log_data: Log::Interfaces::CommonFields).returns(T.untyped) }
+    def fatal(log_data)
+      add(Level::Fatal, log_data)
+    end
+
+    # Override add to only accept LogStruct log classes
+    sig { params(level: Level, log_data: Log::Interfaces::CommonFields, progname: T.nilable(String)).returns(T.untyped) }
+    def add(level, log_data, progname = nil)
+      # Get the numeric severity for comparison with logger level
+      severity_int = level.to_severity_int
+      
+      # Early return if below current level
+      return true if @level && @level > severity_int
+
+      # Pass to super with correct parameters for ActiveSupport::Logger
+      super(severity_int, nil, log_data)
+    end
+  end
+end