lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/adapters/appsignal_adapter.rb

@@ -2,7 +2,6 @@
 
 require "json"
 require "socket"
-require_relative "../http_client"
 
 module Lapsoss
   module Adapters
@@ -12,10 +11,10 @@ module Lapsoss
       JSON_CONTENT_TYPE = "application/json; charset=UTF-8"
 
       def initialize(name, settings = {})
-        super(name, settings)
-        @push_api_key = settings[:push_api_key] || ENV["APPSIGNAL_PUSH_API_KEY"]
-        @frontend_api_key = settings[:frontend_api_key] || ENV["APPSIGNAL_FRONTEND_API_KEY"]
-        @app_name = settings[:app_name] || ENV["APPSIGNAL_APP_NAME"]
+        super
+        @push_api_key = settings[:push_api_key] || ENV.fetch("APPSIGNAL_PUSH_API_KEY", nil)
+        @frontend_api_key = settings[:frontend_api_key] || ENV.fetch("APPSIGNAL_FRONTEND_API_KEY", nil)
+        @app_name = settings[:app_name] || ENV.fetch("APPSIGNAL_APP_NAME", nil)
         @environment = Lapsoss.configuration.environment
 
         validate_settings!
@@ -83,7 +82,7 @@ module Lapsoss
         # Instead of creating fake exceptions, we'll structure the message properly
         # but clearly indicate it's a log message, not an exception
 
-        unless [:error, :fatal, :critical].include?(event.level)
+        unless %i[error fatal critical].include?(event.level)
           # Log when messages are dropped due to level filtering
           Lapsoss.configuration.logger&.debug(
             "[Lapsoss::AppsignalAdapter] Dropping message with level '#{event.level}' - " \
@@ -98,9 +97,9 @@ module Lapsoss
           exception: {
             # AppSignal requires exception format for messages - this isn't a real exception
             # but rather a way to send structured log messages through their error API
-            name: "LogMessage",  # Clear indication this is a log message
+            name: "LogMessage", # Clear indication this is a log message
             message: event.message,
-            backtrace: []  # No fake backtrace for log messages
+            backtrace: [] # No fake backtrace for log messages
           },
           tags: stringify_hash(event.context[:tags]),
           params: stringify_hash(event.context[:params]),

data/lib/lapsoss/adapters/base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../http_client"
-require_relative "../validators"
-
 module Lapsoss
   module Adapters
     class Base

data/lib/lapsoss/adapters/bugsnag_adapter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Adapters
+    # Bugsnag adapter - backwards compatibility with InsightHub adapter
+    # This allows users to configure with :bugsnag type but uses InsightHub implementation
+    # The InsightHub adapter already checks for BUGSNAG_API_KEY environment variable
+    class BugsnagAdapter < InsightHubAdapter
+      # Inherits all functionality from InsightHubAdapter
+    end
+  end
+end

data/lib/lapsoss/adapters/insight_hub_adapter.rb

@@ -1,30 +1,20 @@
 # frozen_string_literal: true
 
 require "json"
-require "socket"
-require_relative "../http_client"
-require_relative "../backtrace_processor"
 
 module Lapsoss
   module Adapters
-    # Adapter for Insight Hub (formerly Bugsnag)
-    # Note: The API endpoints still use bugsnag.com domains for backwards compatibility
     class InsightHubAdapter < Base
-      NOTIFY_URI = "https://notify.bugsnag.com"
-      SESSION_URI = "https://sessions.bugsnag.com"
+      API_URI = "https://notify.bugsnag.com"
       JSON_CONTENT_TYPE = "application/json"
 
       def initialize(name, settings = {})
-        super(name, settings)
-        @api_key = settings[:api_key] || ENV["INSIGHT_HUB_API_KEY"] || ENV["BUGSNAG_API_KEY"]
-        @release_stage = settings[:release_stage] || Lapsoss.configuration.environment
-        @app_version = settings[:app_version]
-        @app_type = settings[:app_type] || "ruby"
+        super
+        @api_key = settings[:api_key] || ENV.fetch("INSIGHT_HUB_API_KEY", nil)
 
         validate_settings!
 
-        @notify_client = create_http_client(NOTIFY_URI)
-        @session_client = create_http_client(SESSION_URI) if settings[:enable_sessions]
+        @client = create_http_client(API_URI)
         @backtrace_processor = BacktraceProcessor.new
       end
 
@@ -34,134 +24,113 @@ module Lapsoss
         payload = build_payload(event)
         return unless payload
 
-        headers = {
-          "Content-Type" => JSON_CONTENT_TYPE,
-          "Bugsnag-Api-Key" => @api_key,
-          "Bugsnag-Payload-Version" => "5.0",
-          "Bugsnag-Sent-At" => Time.now.utc.iso8601
-        }
-
-        begin
-          @notify_client.post("/", body: JSON.generate(payload), headers: headers)
-        rescue DeliveryError => e
-          # Log the error and potentially notify error handler
-          Lapsoss.configuration.logger&.error("[Lapsoss::InsightHubAdapter] Failed to deliver event: #{e.message}")
-          Lapsoss.configuration.error_handler&.call(e)
+        response = @client.post("/", body: payload.to_json, headers: {
+                                  "Content-Type" => JSON_CONTENT_TYPE,
+                                  "Bugsnag-Api-Key" => @api_key,
+                                  "Bugsnag-Payload-Version" => "5"
+                                })
 
-          # Re-raise to let the caller know delivery failed
-          raise
-        end
-      end
-
-      def shutdown
-        @notify_client&.shutdown
-        @session_client&.shutdown
-        super
+        handle_response(response, event)
+      rescue StandardError => e
+        handle_delivery_error(e)
       end
 
       def capabilities
         super.merge(
-          code_context: true,
           breadcrumbs: true,
+          user_tracking: true,
+          custom_context: true,
+          release_tracking: true,
           sessions: true
         )
       end
 
+      def validate!
+        validate_settings!
+        true
+      end
+
       private
 
       def build_payload(event)
         {
           apiKey: @api_key,
-          payloadVersion: "5.0",
+          payloadVersion: "5",
           notifier: {
-            name: "Lapsoss",
+            name: "Lapsoss Ruby",
             version: Lapsoss::VERSION,
-            url: "https://github.com/seuros/lapsoss"
+            url: "https://github.com/yourusername/lapsoss"
           },
-          events: [build_event(event)]
+          events: [ build_event(event) ]
         }
       end
 
       def build_event(event)
-        base_event = {
-          app: {
-            version: @app_version,
-            releaseStage: @release_stage,
-            type: @app_type
-          },
-          device: {
-            hostname: Socket.gethostname,
-            runtimeVersions: {
-              ruby: RUBY_VERSION
-            }
-          },
+        {
+          app: build_app_data(event),
+          device: build_device_data,
+          exceptions: build_exceptions(event),
+          breadcrumbs: build_breadcrumbs(event),
+          request: event.request_context,
+          user: build_user_data(event),
+          context: event.context[:custom]&.dig(:context) || "production",
           severity: map_severity(event.level),
           unhandled: event.context[:unhandled] || false,
-          severityReason: {
-            type: event.context[:unhandled] ? "unhandledException" : "handledException"
-          },
-          user: build_user(event),
-          context: event.context[:context],
-          groupingHash: event.context[:fingerprint],
-          breadcrumbs: build_breadcrumbs(event),
-          metaData: event.context[:extra] || {}
-        }
-
-        case event.type
-        when :exception
-          base_event.merge(build_exception_data(event))
-        when :message
-          base_event.merge(build_message_data(event))
-        end
+          metaData: event.context[:custom] || {}
+        }.compact
       end
 
-      def build_exception_data(event)
-        {
-          exceptions: [{
-            errorClass: event.exception.class.name,
-            message: event.exception.message,
-            stacktrace: build_stacktrace(event.exception),
-            type: "ruby"
-          }]
-        }
-      end
+      def build_exceptions(event)
+        return [] unless event.type == :exception && event.exception
 
-      def build_message_data(event)
-        {
-          exceptions: [{
-            # Insight Hub (Bugsnag) requires exception format for messages - this isn't a real exception
-            # but rather a way to send structured log messages through their error API
-            errorClass: "LogMessage",  # Clear indication this is a log message
-            message: event.message,
-            stacktrace: [],  # No fake backtrace for log messages
-            type: "log"      # Mark as log type, not ruby exception
-          }]
-        }
+        [ {
+          errorClass: event.exception_type,
+          message: event.message,
+          stacktrace: build_stacktrace(event.exception),
+          type: "ruby"
+        } ]
       end
 
       def build_stacktrace(exception)
-        return [] unless exception
-
-        frames = @backtrace_processor.process_exception(exception)
+        frames = @backtrace_processor.process_exception(exception, follow_cause: true)
         @backtrace_processor.format_frames(frames, :bugsnag)
       end
 
+      def build_app_data(event)
+        {
+          id: event.context[:app]&.dig(:id),
+          version: event.context[:release]&.dig(:version),
+          releaseStage: @environment || "production",
+          type: detect_app_type
+        }.compact
+      end
+
+      def build_device_data
+        {
+          hostname: Socket.gethostname,
+          osName: RUBY_PLATFORM,
+          runtimeVersions: {
+            ruby: RUBY_VERSION
+          }
+        }
+      end
 
       def build_breadcrumbs(event)
         breadcrumbs = event.context[:breadcrumbs] || []
+
         breadcrumbs.map do |crumb|
           {
-            timestamp: crumb[:timestamp]&.iso8601 || Time.now.utc.iso8601,
-            name: crumb[:message] || crumb[:name],
+            timestamp: crumb[:timestamp]&.iso8601,
+            name: crumb[:message],
             type: crumb[:type] || "manual",
             metaData: crumb[:data] || {}
           }
         end
       end
 
-      def build_user(event)
+      def build_user_data(event)
         user = event.context[:user]
-        return unless user
+        return nil unless user
 
         {
           id: user[:id]&.to_s,
@@ -173,17 +142,49 @@ module Lapsoss
       def map_severity(level)
         case level
         when :debug, :info then "info"
-        when :warning, :warn then "warning"
-        when :error, :fatal, :critical then "error"
+        when :warning then "warning"
+        when :error, :fatal then "error"
         else "error"
         end
       end
 
+      def detect_app_type
+        return "rails" if defined?(Rails)
+        return "rack" if defined?(Rack)
+
+        "ruby"
+      end
+
+      def handle_response(response, _event)
+        case response.status
+        when 200
+          true
+        when 400
+          body = begin
+            JSON.parse(response.body)
+          rescue
+            {}
+          end
+          raise DeliveryError.new("Bad request: #{body['errors']&.join(', ')}", response: response)
+        when 401
+          raise DeliveryError.new("Unauthorized: Invalid API key", response: response)
+        when 413
+          raise DeliveryError.new("Payload too large", response: response)
+        when 429
+          raise DeliveryError.new("Rate limit exceeded", response: response)
+        else
+          raise DeliveryError.new("Unexpected response: #{response.status}", response: response)
+        end
+      end
+
       def validate_settings!
         validate_presence!(@api_key, "Insight Hub API key")
         validate_api_key!(@api_key, "Insight Hub API key", format: :alphanumeric) if @api_key
-        validate_environment!(@app_version, "Insight Hub app version") if @app_version
-        validate_type!(@release_stage, [String, Symbol], "Insight Hub release stage") if @release_stage
+      end
+
+      def handle_delivery_error(error, response = nil)
+        message = "Insight Hub delivery failed: #{error.message}"
+        raise DeliveryError.new(message, response: response, cause: error)
       end
     end
   end

data/lib/lapsoss/adapters/logger_adapter.rb

@@ -7,7 +7,7 @@ module Lapsoss
     class LoggerAdapter < Base
       def initialize(name, settings = {})
         @logger = settings[:logger] || Logger.new($stdout)
-        super(name, settings)
+        super
       end
 
       def capabilities
@@ -28,12 +28,12 @@ module Lapsoss
         end
 
         # Log breadcrumbs if present in the event context
-        if event.context[:breadcrumbs]&.any?
-          event.context[:breadcrumbs].each do |breadcrumb|
-            breadcrumb_msg = "[BREADCRUMB] [#{breadcrumb[:type].upcase}] #{breadcrumb[:message]}"
-            breadcrumb_msg += " | #{breadcrumb[:metadata].inspect}" unless breadcrumb[:metadata].empty?
-            @logger.debug(breadcrumb_msg)
-          end
+        return unless event.context[:breadcrumbs]&.any?
+
+        event.context[:breadcrumbs].each do |breadcrumb|
+          breadcrumb_msg = "[BREADCRUMB] [#{breadcrumb[:type].upcase}] #{breadcrumb[:message]}"
+          breadcrumb_msg += " | #{breadcrumb[:metadata].inspect}" unless breadcrumb[:metadata].empty?
+          @logger.debug(breadcrumb_msg)
         end
       end
 

data/lib/lapsoss/adapters/rollbar_adapter.rb

@@ -3,8 +3,6 @@
 require "json"
 require "socket"
 require "securerandom"
-require_relative "../http_client"
-require_relative "../backtrace_processor"
 
 module Lapsoss
   module Adapters
@@ -14,8 +12,8 @@ module Lapsoss
       JSON_CONTENT_TYPE = "application/json"
 
       def initialize(name, settings = {})
-        super(name, settings)
-        @access_token = settings[:access_token] || ENV["ROLLBAR_ACCESS_TOKEN"]
+        super
+        @access_token = settings[:access_token] || ENV.fetch("ROLLBAR_ACCESS_TOKEN", nil)
         @environment = settings[:environment] || Lapsoss.configuration.environment || "development"
 
         validate_settings!
@@ -30,62 +28,50 @@ module Lapsoss
         payload = build_payload(event)
         return unless payload
 
-        path = "/api/#{API_VERSION}/item/"
-        headers = {
-          "Content-Type" => JSON_CONTENT_TYPE,
-          "X-Rollbar-Access-Token" => @access_token
-        }
-
-        begin
-          @client.post(path, body: JSON.generate(payload), headers: headers)
-        rescue DeliveryError => e
-          # Log the error and potentially notify error handler
-          Lapsoss.configuration.logger&.error("[Lapsoss::RollbarAdapter] Failed to deliver event: #{e.message}")
-          Lapsoss.configuration.error_handler&.call(e)
-
-          # Re-raise to let the caller know delivery failed
-          raise
-        end
-      end
+        response = @client.post("/api/#{API_VERSION}/item/", body: payload.to_json, headers: {
+                                  "Content-Type" => JSON_CONTENT_TYPE,
+                                  "X-Rollbar-Access-Token" => @access_token
+                                })
 
-      def shutdown
-        @client&.shutdown
-        super
+        handle_response(response, event)
+      rescue StandardError => e
+        handle_delivery_error(e)
       end
 
       def capabilities
         super.merge(
-          code_context: true
+          breadcrumbs: true,
+          user_tracking: true,
+          custom_context: true,
+          release_tracking: true
         )
       end
 
+      def validate!
+        validate_settings!
+        true
+      end
+
       private
 
       def build_payload(event)
-        data = {
-          environment: @environment,
-          body: build_body(event),
-          level: map_level(event.level),
-          timestamp: event.timestamp.to_i,
-          platform: "ruby",
-          language: "ruby",
-          framework: detect_framework,
-          context: event.context[:context],
-          request: event.context[:request],
-          person: build_person(event),
-          custom: event.context[:extra] || {},
-          title: event.message || (event.exception&.message if event.type == :exception),
-          uuid: SecureRandom.uuid,
-          notifier: {
-            name: "lapsoss",
-            version: Lapsoss::VERSION
+        {
+          access_token: @access_token,
+          data: {
+            environment: @environment,
+            body: build_body(event),
+            level: map_level(event.level),
+            timestamp: event.timestamp.to_i,
+            code_version: event.context[:release]&.dig(:commit_sha),
+            platform: "ruby",
+            language: "ruby",
+            framework: detect_framework,
+            server: build_server_data,
+            person: build_person_data(event),
+            request: event.request_context,
+            custom: event.context[:custom] || {}
           }
         }
-
-        # Only add fingerprint if it exists
-        data[:fingerprint] = event.context[:fingerprint].to_s if event.context[:fingerprint]
-
-        { data: data }
       end
 
       def build_body(event)
@@ -95,9 +81,9 @@ module Lapsoss
             trace: {
               frames: build_backtrace_frames(event.exception),
               exception: {
-                class: event.exception.class.name,
-                message: event.exception.message,
-                description: event.exception.message
+                class: event.exception_type,
+                message: event.message,
+                description: event.exception.to_s
               }
             }
           }
@@ -119,9 +105,9 @@ module Lapsoss
         formatted_frames.reverse
       end
 
-      def build_person(event)
+      def build_person_data(event)
         user = event.context[:user]
-        return unless user
+        return nil unless user
 
         {
           id: user[:id]&.to_s,
@@ -130,13 +116,22 @@ module Lapsoss
         }.compact
       end
 
+      def build_server_data
+        {
+          host: Socket.gethostname,
+          root: defined?(Rails) ? Rails.root.to_s : Dir.pwd,
+          branch: git_branch,
+          code_version: git_sha
+        }.compact
+      end
+
       def map_level(level)
         case level
         when :debug then "debug"
         when :info then "info"
-        when :warning, :warn then "warning"
+        when :warning then "warning"
         when :error then "error"
-        when :fatal, :critical then "critical"
+        when :fatal then "critical"
         else "error"
         end
       end
@@ -144,14 +139,58 @@ module Lapsoss
       def detect_framework
         return "rails" if defined?(Rails)
         return "sinatra" if defined?(Sinatra)
+
         "ruby"
       end
 
+      def git_branch
+        `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip.presence
+      rescue StandardError
+        nil
+      end
+
+      def git_sha
+        `git rev-parse HEAD 2>/dev/null`.strip.presence
+      rescue StandardError
+        nil
+      end
+
+      def handle_response(response, event)
+        case response.code.to_i
+        when 200
+          true
+        when 400
+          handle_client_error(response, event)
+        when 401
+          raise DeliveryError.new("Unauthorized: Invalid access token", response: response)
+        when 429
+          raise DeliveryError.new("Rate limit exceeded", response: response)
+        else
+          raise DeliveryError.new("Unexpected response: #{response.code}", response: response)
+        end
+      end
+
+      def handle_client_error(response, _event)
+        body = begin
+          JSON.parse(response.body)
+        rescue
+          {}
+        end
+        error_msg = body["message"] || "Bad request"
+
+        raise DeliveryError.new("Client error: #{error_msg}", response: response)
+      end
+
       def validate_settings!
         validate_presence!(@access_token, "Rollbar access token")
         validate_api_key!(@access_token, "Rollbar access token", format: :alphanumeric) if @access_token
         validate_environment!(@environment, "Rollbar environment") if @environment
       end
+
+      def handle_delivery_error(error, response = nil)
+        message = "Rollbar delivery failed: #{error.message}"
+        raise DeliveryError.new(message, response: response, cause: error)
+      end
     end
   end
 end

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require_relative "../http_client"
-require_relative "../backtrace_processor"
 
 module Lapsoss
   module Adapters
@@ -10,10 +8,10 @@ module Lapsoss
       PROTOCOL_VERSION = 7
       CONTENT_TYPE = "application/x-sentry-envelope"
       GZIP_THRESHOLD = 1024 * 30 # 30KB
-      USER_AGENT = "lapsoss/#{Lapsoss::VERSION}"
+      USER_AGENT = "lapsoss/#{Lapsoss::VERSION}".freeze
 
       def initialize(name, settings = {})
-        super(name, settings)
+        super
         validate_settings!
         return unless settings[:dsn]
 
@@ -69,7 +67,7 @@ module Lapsoss
         item_header = { type: item_type, content_type: "application/json" }
         item_payload = build_event_payload(event)
 
-        [header, item_header, item_payload]
+        [ header, item_header, item_payload ]
       end
 
       def serialize_envelope(envelope)
@@ -82,9 +80,9 @@ module Lapsoss
         ].join("\n")
 
         if body.bytesize >= GZIP_THRESHOLD
-          [Zlib.gzip(body), true]
+          [ Zlib.gzip(body), true ]
         else
-          [body, false]
+          [ body, false ]
         end
       end
 
@@ -107,11 +105,11 @@ module Lapsoss
         when :exception
           {
             exception: {
-              values: [{
+              values: [ {
                 type: event.exception.class.name,
                 value: event.exception.message,
                 stacktrace: { frames: parse_backtrace(event.exception.backtrace) }
-              }]
+              } ]
             }
           }
         when :message
@@ -151,9 +149,7 @@ module Lapsoss
         api_path = uri.path
 
         # For standard Sentry DSNs (just /project_id), build the envelope path
-        if path_parts.length == 1 && project_id.match?(/^\d+$/)
-          api_path = "/api/#{project_id}/envelope/"
-        end
+        api_path = "/api/#{project_id}/envelope/" if path_parts.length == 1 && project_id.match?(/^\d+$/)
 
         {
           public_key: uri.user,
@@ -186,11 +182,9 @@ module Lapsoss
       end
 
       def validate_settings!
-        if @settings[:dsn]
-          validate_dsn!(@settings[:dsn], "Sentry DSN")
-        else
-          raise ValidationError, "Sentry DSN is required"
-        end
+        raise ValidationError, "Sentry DSN is required" unless @settings[:dsn]
+
+        validate_dsn!(@settings[:dsn], "Sentry DSN")
       end
     end
   end