lapsoss 0.2.0 → 0.3.1

data/lib/lapsoss/rails_middleware.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class RailsMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Lapsoss::Current.with_clean_scope do
+        # Add request context to current scope
+        if Lapsoss.configuration.capture_request_context
+          Rails.logger.debug "[Lapsoss] Adding request context" if Rails.env.test?
+          add_request_context(env)
+        end
+
+        begin
+          @app.call(env)
+        rescue Exception => e
+          Rails.logger.debug { "[Lapsoss] Capturing exception: #{e.class} - #{e.message}" } if Rails.env.test?
+          # Capture the exception
+          Lapsoss.capture_exception(e)
+          # Re-raise the exception to maintain Rails error handling
+          raise
+        end
+      end
+    end
+
+    private
+
+    def add_request_context(env)
+      request = Rack::Request.new(env)
+
+      return unless Lapsoss::Current.scope
+
+      Lapsoss::Current.scope.set_context("request", {
+                                           method: request.request_method,
+                                           url: request.url,
+                                           path: request.path,
+                                           query_string: request.query_string,
+                                           headers: extract_headers(env),
+                                           ip: request.ip,
+                                           user_agent: request.user_agent,
+                                           referer: request.referer,
+                                           request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+                                         })
+
+      # Add user context if available
+      return unless env["warden"]&.user
+
+      user = env["warden"].user
+      Lapsoss::Current.scope.set_user(
+        id: user.id,
+        email: user.respond_to?(:email) ? user.email : nil
+      )
+    end
+
+    def extract_headers(env)
+      headers = {}
+
+      env.each do |key, value|
+        if key.start_with?("HTTP_") && FILTERED_HEADERS.exclude?(key)
+          header_name = key.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-")
+          headers[header_name] = value
+        end
+      end
+
+      headers
+    end
+
+    FILTERED_HEADERS = %w[
+      HTTP_AUTHORIZATION
+      HTTP_COOKIE
+      HTTP_X_API_KEY
+      HTTP_X_AUTH_TOKEN
+    ].freeze
+  end
+end

data/lib/lapsoss/railtie.rb

@@ -2,71 +2,43 @@
 
 module Lapsoss
   class Railtie < Rails::Railtie
+    Rails.logger.debug "[Lapsoss] Railtie loaded" if ENV["DEBUG_LAPSOSS"]
     config.lapsoss = ActiveSupport::OrderedOptions.new
 
-    initializer 'lapsoss.configure' do |_app|
+    initializer "lapsoss.configure" do |_app|
       Lapsoss.configure do |config|
-        config.environment ||= Rails.env
+        # Use rails_app_version gem if available, otherwise fallback to Rails defaults
+        config.environment ||= if Rails.application.respond_to?(:env)
+                                 Rails.application.env
+        else
+                                 Rails.env
+        end
+
         config.logger ||= Rails.logger
-        config.release ||= Rails.application.config.try(:release)
+
+        config.release ||= if Rails.application.respond_to?(:version)
+                             Rails.application.version.to_s
+        else
+                             Rails.application.config.try(:release)
+        end
 
         # Set default tags
         config.default_tags = {
-          rails_env: Rails.env,
+          rails_env: config.environment,
           rails_version: Rails.version
         }
       end
     end
 
-    initializer 'lapsoss.add_middleware', after: 'lapsoss.configure' do |app|
-      app.middleware.insert_before ActionDispatch::ShowExceptions, Lapsoss::Middleware
-    end
-
-    initializer 'lapsoss.rails_error_subscriber', after: 'lapsoss.add_middleware' do |app|
-      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
-    end
-
-    rake_tasks do
-      # Add any Lapsoss-specific rake tasks here
-    end
-  end
-
-  class RailsErrorSubscriber
-    def report(error, handled:, severity:, context:, source: nil)
-      # Skip certain framework errors
-      return if skip_error?(error, source)
-
-      level = map_severity(severity)
+    initializer "lapsoss.add_middleware" do |app|
+      require "lapsoss/rails_middleware"
 
-      Lapsoss.capture_exception(
-        error,
-        level: level,
-        tags: {
-          handled: handled,
-          source: source || 'rails'
-        },
-        context: context
-      )
+      # Use config.middleware to ensure it's added during initialization
+      app.config.middleware.use Lapsoss::RailsMiddleware
     end
 
-    private
-
-    def skip_error?(error, source)
-      # Skip cache-related Redis errors if configured to do so
-      if Lapsoss.configuration.skip_rails_cache_errors && source&.include?('cache') && error.is_a?(Redis::CannotConnectError)
-        return true
-      end
-
-      false
-    end
-
-    def map_severity(severity)
-      case severity
-      when :error then :error
-      when :warning then :warning
-      when :info then :info
-      else :error
-      end
+    initializer "lapsoss.rails_error_subscriber", after: "lapsoss.add_middleware" do |app|
+      app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
     end
   end
 end

data/lib/lapsoss/registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require 'concurrent'
+require "singleton"
+require "concurrent"
 
 module Lapsoss
   class Registry
@@ -36,11 +36,17 @@ module Lapsoss
     #
     # @param adapter [Adapter] The adapter instance to register
     def register_adapter(adapter)
+      # Ensure we're getting an adapter instance, not a config hash
+      raise ArgumentError, "Expected an adapter instance, got #{adapter.class}" unless adapter.respond_to?(:capture)
+
       name = if adapter.respond_to?(:name) && adapter.name
                adapter.name.to_sym
-             else
-               adapter.class.name.split('::').last.to_sym
-             end
+      elsif adapter.class.name
+               adapter.class.name.split("::").last.to_sym
+      else
+               # Generate a unique name if class name is nil (anonymous class)
+               :"adapter_#{adapter.object_id}"
+      end
       @adapters[name] = adapter
     end
 
@@ -98,6 +104,13 @@ module Lapsoss
       @adapters.keys
     end
 
+    # Get all registered adapters (alias for all)
+    #
+    # @return [Array<Adapter>] All adapter instances
+    def adapters
+      all
+    end
+
     private
 
     # Resolve adapter type to class

data/lib/lapsoss/release_providers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lapsoss
+  # Built-in release providers for common scenarios
+  class ReleaseProviders
+    def self.from_file(file_path)
+      lambda do
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path).strip
+        return nil if content.empty?
+
+        # Try to parse as JSON first
+        begin
+          JSON.parse(content)
+        rescue JSON::ParserError
+          # Treat as plain text version
+          { version: content }
+        end
+      end
+    end
+
+    def self.from_ruby_constant(constant_name)
+      lambda do
+        constant = Object.const_get(constant_name)
+        { version: constant.to_s }
+      rescue NameError
+        nil
+      end
+    end
+
+    def self.from_gemfile_lock
+      lambda do
+        return nil unless File.exist?("Gemfile.lock")
+
+        content = File.read("Gemfile.lock")
+
+        # Extract gems with versions
+        gems = {}
+        content.scan(/^\s{4}(\w+)\s+\(([^)]+)\)/).each do |name, version|
+          gems[name] = version
+        end
+
+        { gems: gems }
+      end
+    end
+
+    def self.from_package_json
+      lambda do
+        return nil unless File.exist?("package.json")
+
+        begin
+          package_info = JSON.parse(File.read("package.json"))
+          {
+            version: package_info["version"],
+            name: package_info["name"],
+            dependencies: package_info["dependencies"]&.keys
+          }.compact
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+
+    def self.from_rails_application
+      lambda do
+        return nil unless defined?(Rails) && Rails.respond_to?(:application)
+
+        app = Rails.application
+        return nil unless app
+
+        info = {
+          rails_version: Rails.version,
+          environment: Rails.env,
+          root: Rails.root.to_s
+        }
+
+        # Get application version if defined
+        info[:app_version] = app.class.version if app.class.respond_to?(:version)
+
+        # Get application name
+        info[:app_name] = app.class.name if app.class.respond_to?(:name)
+
+        info
+      end
+    end
+
+    def self.from_capistrano
+      lambda do
+        # Check for Capistrano deployment files
+        %w[REVISION current/REVISION].each do |file|
+          next unless File.exist?(file)
+
+          revision = File.read(file).strip
+          next if revision.empty?
+
+          return {
+            revision: revision,
+            deployed_at: File.mtime(file),
+            deployment_method: "capistrano"
+          }
+        end
+
+        nil
+      end
+    end
+  end
+end