lapsoss 0.1.0 → 0.3.0

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.rails_error_subscriber", after: "lapsoss.configure" do |app|
-      if Rails.version.to_f >= 7.0
-        app.executor.error_reporter.subscribe(Lapsoss::RailsErrorSubscriber.new)
-      end
-    end
-
+    initializer "lapsoss.add_middleware" do |app|
+      require "lapsoss/rails_middleware"
 
-
-    rake_tasks do
-      # Add any Lapsoss-specific rake tasks here
+      # Use config.middleware to ensure it's added during initialization
+      app.config.middleware.use Lapsoss::RailsMiddleware
     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)
 
-      Lapsoss.capture_exception(
-        error,
-        level: level,
-        tags: {
-          handled: handled,
-          source: source || "rails"
-        },
-        context: context
-      )
-    end
-
-    private
-
-    def skip_error?(error, source)
-      # Skip cache-related Redis errors if configured to do so
-      if Lapsoss.configuration.skip_rails_cache_errors
-        return true if source&.include?("cache") && error.is_a?(Redis::CannotConnectError)
-      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

@@ -2,12 +2,6 @@
 
 require "singleton"
 require "concurrent"
-require_relative "adapters/base"
-require_relative "adapters/logger_adapter"
-require_relative "adapters/sentry_adapter"
-require_relative "adapters/appsignal_adapter"
-require_relative "adapters/rollbar_adapter"
-require_relative "adapters/insight_hub_adapter"
 
 module Lapsoss
   class Registry
@@ -38,12 +32,30 @@ module Lapsoss
       adapter
     end
 
+    # Register an adapter instance directly (for testing)
+    #
+    # @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
+      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
+
     # Unregister an adapter
     #
     # @param name [Symbol] The adapter name to remove
     def unregister(name)
       adapter = @adapters.delete(name.to_sym)
-      adapter&.shutdown if adapter&.respond_to?(:shutdown)
+      adapter&.shutdown if adapter.respond_to?(:shutdown)
       adapter
     end
 
@@ -79,7 +91,7 @@ module Lapsoss
 
     # Clear all adapters
     def clear!
-      @adapters.values.each do |adapter|
+      @adapters.each_value do |adapter|
         adapter.shutdown if adapter.respond_to?(:shutdown)
       end
       @adapters.clear
@@ -92,23 +104,25 @@ 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
     def resolve_adapter_class(type)
-      adapter_map[type.to_sym] || raise(AdapterNotFoundError, "Unknown adapter type: #{type}")
-    end
+      # Try to get the class by convention: Adapters::{Type}Adapter
+      class_name = "#{type.to_s.split('_').map(&:capitalize).join}Adapter"
 
-    # Map of adapter types to classes
-    def adapter_map
-      {
-        logger: Adapters::LoggerAdapter,
-        sentry: Adapters::SentryAdapter,
-        appsignal: Adapters::AppsignalAdapter,
-        rollbar: Adapters::RollbarAdapter,
-        insight_hub: Adapters::InsightHubAdapter,
-        bugsnag: Adapters::InsightHubAdapter # Backwards compatibility
-      }
+      begin
+        Adapters.const_get(class_name)
+      rescue NameError
+        raise AdapterNotFoundError, "Unknown adapter type: #{type}. Expected class: Lapsoss::Adapters::#{class_name}"
+      end
     end
   end
 end

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