logstruct 0.0.2 → 0.1.1

data/lib/log_struct/integrations/active_storage.rb

@@ -38,7 +38,7 @@ module LogStruct
         # Extract key information from the event
         event_name = event.name.sub(/\.active_storage$/, "")
         service_name = event.payload[:service]
-        duration = event.duration
+        duration_ms = event.duration
 
         # Map service events to log event types
         event_type = case event_name
@@ -65,26 +65,65 @@ module LogStruct
         end
 
         # Map the event name to an operation
-        operation = event_name.sub(/^service_/, "").to_sym
+        event_name.sub(/^service_/, "").to_sym
 
-        # Create structured log event specific to ActiveStorage
-        log_data = Log::ActiveStorage.new(
-          event: event_type,
-          operation: operation,
-          storage: service_name.to_s,
-          file_id: event.payload[:key].to_s,
-          checksum: event.payload[:checksum].to_s,
-          duration: duration,
-          # Add other fields where available
-          metadata: event.payload[:metadata],
-          exist: event.payload[:exist],
-          url: event.payload[:url],
-          filename: event.payload[:filename],
-          mime_type: event.payload[:content_type],
-          size: event.payload[:byte_size],
-          prefix: event.payload[:prefix],
-          range: event.payload[:range]
-        )
+        # Create structured log event using generated classes
+        log_data = case event_type
+        when Event::Upload
+          Log::ActiveStorage::Upload.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            checksum: event.payload[:checksum]&.to_s,
+            duration_ms: duration_ms,
+            metadata: event.payload[:metadata],
+            filename: event.payload[:filename],
+            mime_type: event.payload[:content_type],
+            size: event.payload[:byte_size]
+          )
+        when Event::Download
+          Log::ActiveStorage::Download.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            filename: event.payload[:filename],
+            range: event.payload[:range],
+            duration_ms: duration_ms
+          )
+        when Event::Delete
+          Log::ActiveStorage::Delete.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s
+          )
+        when Event::Metadata
+          Log::ActiveStorage::Metadata.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            metadata: event.payload[:metadata]
+          )
+        when Event::Exist
+          Log::ActiveStorage::Exist.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            exist: event.payload[:exist]
+          )
+        when Event::Stream
+          Log::ActiveStorage::Stream.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            prefix: event.payload[:prefix]
+          )
+        when Event::Url
+          Log::ActiveStorage::Url.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            url: event.payload[:url]
+          )
+        else
+          Log::ActiveStorage::Metadata.new(
+            storage: service_name.to_s,
+            file_id: event.payload[:key]&.to_s,
+            metadata: event.payload[:metadata]
+          )
+        end
 
         # Log structured data
         LogStruct.info(log_data)

data/lib/log_struct/integrations/ahoy.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    # Ahoy analytics integration. If Ahoy is present, prepend a small hook to
+    # Ahoy::Tracker#track to emit a structured log for analytics events.
+    module Ahoy
+      extend T::Sig
+
+      sig { params(config: LogStruct::Configuration).returns(T.nilable(TrueClass)) }
+      def self.setup(config)
+        return nil unless defined?(::Ahoy)
+
+        if defined?(::Ahoy::Tracker)
+          mod = Module.new do
+            extend T::Sig
+
+            sig { params(name: T.untyped, properties: T.nilable(T::Hash[T.untyped, T.untyped]), options: T.untyped).returns(T.untyped) }
+            def track(name, properties = nil, options = nil)
+              result = super
+              begin
+                # Emit a lightweight structured log about the analytics event
+                data = {
+                  ahoy_event: T.let(name, T.untyped)
+                }
+                data[:properties] = properties if properties
+                LogStruct.info(
+                  LogStruct::Log::Ahoy.new(
+                    message: "ahoy.track",
+                    ahoy_event: T.must(T.let(name, T.nilable(String))),
+                    properties: T.let(
+                      properties && properties.transform_keys { |k| k.to_sym },
+                      T.nilable(T::Hash[Symbol, T.untyped])
+                    ),
+                    additional_data: {}
+                  )
+                )
+              rescue => e
+                # Never raise from logging; rely on global error handling policies
+                LogStruct.handle_exception(e, source: LogStruct::Source::App, context: {integration: :ahoy})
+              end
+              result
+            end
+          end
+
+          T.unsafe(::Ahoy::Tracker).prepend(mod)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/carrierwave.rb

@@ -52,18 +52,16 @@ module LogStruct
           }
 
           # Log the store operation with structured data
-          log_data = Log::CarrierWave.new(
-            source: Source::CarrierWave,
-            event: Event::Upload,
-            duration: duration * 1000.0, # Convert to ms
-            model: model.class.name,
-            uploader: self.class.name,
+          log_data = Log::CarrierWave::Upload.new(
             storage: storage.class.name,
-            mount_point: mounted_as.to_s,
+            file_id: identifier,
             filename: file.filename,
             mime_type: file.content_type,
             size: file_size,
-            file_id: identifier,
+            duration_ms: (duration * 1000.0).to_f,
+            uploader: self.class.name,
+            model: model.class.name,
+            mount_point: mounted_as.to_s,
             additional_data: {
               version: version_name.to_s,
               store_path: store_path,
@@ -78,25 +76,24 @@ module LogStruct
         # Log file retrieve operations
         sig { params(identifier: T.untyped, args: T.untyped).returns(T.untyped) }
         def retrieve_from_store!(identifier, *args)
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
           result = super
-          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           # Extract file information if available
           file_size = file.size if file&.respond_to?(:size)
 
           # Log the retrieve operation with structured data
-          log_data = Log::CarrierWave.new(
-            source: Source::CarrierWave,
-            event: Event::Download,
-            duration: duration * 1000.0, # Convert to ms
-            uploader: self.class.name,
+          log_data = Log::CarrierWave::Download.new(
             storage: storage.class.name,
-            mount_point: mounted_as.to_s,
             file_id: identifier,
             filename: file&.filename,
             mime_type: file&.content_type,
             size: file_size,
+            # No duration field on Download event schema
+            uploader: self.class.name,
+            model: model.class.name,
+            mount_point: mounted_as.to_s,
             additional_data: {
               version: version_name.to_s
             }

data/lib/log_struct/integrations/dotenv.rb

@@ -0,0 +1,278 @@
+# typed: strict
+# frozen_string_literal: true
+
+# rubocop:disable Sorbet/ConstantsFromStrings
+require_relative "../boot_buffer"
+require "pathname"
+
+begin
+  require "dotenv-rails"
+rescue LoadError
+  # Dotenv-rails gem is not available, integration will be skipped
+end
+
+module LogStruct
+  module Integrations
+    # Dotenv integration: emits structured logs for load/update/save/restore events
+    module Dotenv
+      extend T::Sig
+      extend IntegrationInterface
+      @original_logger_setter = T.let(nil, T.nilable(UnboundMethod))
+
+      # Internal state holder to avoid duplicate subscriptions in a Sorbet-friendly way
+      State = ::Struct.new(:subscribed)
+      STATE = T.let(State.new(false), State)
+
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        # Subscribe regardless of dotenv gem presence so instrumentation via
+        # ActiveSupport::Notifications can be captured during tests and runtime.
+        subscribe!
+        true
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def subscribe!
+          # Guard against double subscription
+          return if STATE.subscribed
+
+          instrumenter = defined?(::ActiveSupport::Notifications) ? ::ActiveSupport::Notifications : nil
+          return unless instrumenter
+
+          instrumenter.subscribe("load.dotenv") do |*args|
+            # Allow tests to stub Log::Dotenv.new to force an error path
+            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
+
+            ts = event.time ? Time.at(event.time) : Time.now
+            LogStruct.info(Log::Dotenv::Load.new(file: file, timestamp: ts))
+          rescue => e
+            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
+              raise
+            else
+              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+            end
+          end
+
+          instrumenter.subscribe("update.dotenv") do |*args|
+            LogStruct::Log::Dotenv.new
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            diff = event.payload[:diff]
+            vars = diff.env.keys.map(&:to_s)
+
+            ts = event.time ? Time.at(event.time) : Time.now
+            LogStruct.debug(Log::Dotenv::Update.new(vars: vars, timestamp: ts))
+          rescue => e
+            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
+              raise
+            else
+              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+            end
+          end
+
+          instrumenter.subscribe("save.dotenv") do |*args|
+            LogStruct::Log::Dotenv.new
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            ts = event.time ? Time.at(event.time) : Time.now
+            LogStruct.info(Log::Dotenv::Save.new(snapshot: true, timestamp: ts))
+          rescue => e
+            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
+              raise
+            else
+              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+            end
+          end
+
+          instrumenter.subscribe("restore.dotenv") do |*args|
+            LogStruct::Log::Dotenv.new
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            diff = event.payload[:diff]
+            vars = diff.env.keys.map(&:to_s)
+
+            ts = event.time ? Time.at(event.time) : Time.now
+            LogStruct.info(Log::Dotenv::Restore.new(vars: vars, timestamp: ts))
+          rescue => e
+            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
+              raise
+            else
+              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+            end
+          end
+
+          STATE.subscribed = true
+        end
+      end
+
+      # Early boot subscription to buffer structured logs until logger is ready
+      @@boot_subscribed = T.let(false, T::Boolean)
+      sig { void }
+      def self.setup_boot
+        return if @@boot_subscribed
+        return unless defined?(::ActiveSupport::Notifications)
+
+        instrumenter = if Object.const_defined?(:Dotenv)
+          dm = T.unsafe(Object.const_get(:Dotenv))
+          dm.respond_to?(:instrumenter) ? T.unsafe(dm).instrumenter : ::ActiveSupport::Notifications
+        else
+          ::ActiveSupport::Notifications
+        end
+
+        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
+          ts = event.time ? Time.at(event.time) : Time.now
+          LogStruct::BootBuffer.add(Log::Dotenv::Load.new(file: file, timestamp: ts))
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+        end
+
+        instrumenter.subscribe("update.dotenv") do |*args|
+          event = ::ActiveSupport::Notifications::Event.new(*args)
+          diff = event.payload[:diff]
+          vars = diff.env.keys.map(&:to_s)
+          ts = event.time ? Time.at(event.time) : Time.now
+          LogStruct::BootBuffer.add(Log::Dotenv::Update.new(vars: vars, timestamp: ts))
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+        end
+
+        instrumenter.subscribe("save.dotenv") do |*args|
+          event = ::ActiveSupport::Notifications::Event.new(*args)
+          ts = event.time ? Time.at(event.time) : Time.now
+          LogStruct::BootBuffer.add(Log::Dotenv::Save.new(snapshot: true, timestamp: ts))
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+        end
+
+        instrumenter.subscribe("restore.dotenv") do |*args|
+          event = ::ActiveSupport::Notifications::Event.new(*args)
+          diff = event.payload[:diff]
+          vars = diff.env.keys.map(&:to_s)
+          ts = event.time ? Time.at(event.time) : Time.now
+          LogStruct::BootBuffer.add(Log::Dotenv::Restore.new(vars: vars, timestamp: ts))
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+        end
+
+        @@boot_subscribed = true
+      end
+
+      # Intercept Dotenv::Rails#logger= to defer replay until we resolve policy
+      sig { void }
+      def self.intercept_logger_setter!
+        return unless Object.const_defined?(:Dotenv)
+        # Do not intercept when LogStruct is disabled; allow original dotenv replay
+        return unless LogStruct.enabled?
+        dotenv_mod = T.unsafe(Object.const_get(:Dotenv))
+        return unless dotenv_mod.const_defined?(:Rails)
+        klass = T.unsafe(dotenv_mod.const_get(:Rails))
+        return if klass.instance_variable_defined?(:@_logstruct_replay_patched)
+
+        original = klass.instance_method(:logger=)
+        @original_logger_setter = original
+
+        mod = Module.new do
+          define_method :logger= do |new_logger|
+            # Defer replay: store desired logger, keep ReplayLogger as current
+            instance_variable_set(:@logstruct_pending_dotenv_logger, new_logger)
+            new_logger
+          end
+
+          define_method :logstruct_pending_dotenv_logger do
+            instance_variable_get(:@logstruct_pending_dotenv_logger)
+          end
+        end
+
+        klass.prepend(mod)
+        klass.instance_variable_set(:@_logstruct_replay_patched, true)
+      end
+
+      # Decide which boot logs to emit after user initializers
+      sig { void }
+      def self.resolve_boot_logs!
+        # If LogStruct is disabled, do not alter dotenv behavior at all
+        return unless LogStruct.enabled?
+        dotenv_mod = Object.const_defined?(:Dotenv) ? T.unsafe(Object.const_get(:Dotenv)) : nil
+        klass = dotenv_mod&.const_defined?(:Rails) ? T.unsafe(dotenv_mod.const_get(:Rails)) : nil
+
+        pending_logger = nil
+        railtie_instance = nil
+        if klass&.respond_to?(:instance)
+          railtie_instance = klass.instance
+          if railtie_instance.respond_to?(:logstruct_pending_dotenv_logger)
+            pending_logger = T.unsafe(railtie_instance).logstruct_pending_dotenv_logger
+          end
+        end
+
+        if LogStruct.enabled? && LogStruct.config.integrations.enable_dotenv
+          # Structured path
+          if pending_logger && railtie_instance
+            # Clear any buffered original logs
+            current_logger = railtie_instance.logger if railtie_instance.respond_to?(:logger)
+            if current_logger && current_logger.class.name.end_with?("ReplayLogger")
+              begin
+                logs = current_logger.instance_variable_get(:@logs)
+                logs.clear if logs.respond_to?(:clear)
+              rescue
+                # best effort
+              end
+            end
+            railtie_instance.config.dotenv.logger = pending_logger
+          end
+
+          # Detach original subscriber and subscribe runtime structured
+          if dotenv_mod&.const_defined?(:LogSubscriber)
+            T.unsafe(dotenv_mod.const_get(:LogSubscriber)).detach_from(:dotenv)
+          end
+          LogStruct::Integrations::Dotenv.subscribe!
+
+          require_relative "../boot_buffer"
+          LogStruct::BootBuffer.flush
+        else
+          # Original path: replay dotenv lines, drop structured buffer
+          if railtie_instance && @original_logger_setter
+            setter = @original_logger_setter
+            new_logger = pending_logger
+            if new_logger.nil? && ENV["RAILS_LOG_TO_STDOUT"].to_s.strip != ""
+              require "logger"
+              require "active_support/tagged_logging"
+              new_logger = ActiveSupport::TaggedLogging.new(::Logger.new($stdout)).tagged("dotenv")
+            end
+            setter.bind_call(railtie_instance, new_logger) if new_logger
+          end
+          require_relative "../boot_buffer"
+          LogStruct::BootBuffer.clear
+        end
+      end
+    end
+  end
+end
+
+# Subscribe immediately to capture earliest dotenv events into BootBuffer
+LogStruct::Integrations::Dotenv.setup_boot
+
+# rubocop:enable Sorbet/ConstantsFromStrings