lapsoss 0.1.0

data/lib/lapsoss/registry.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+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
+    include Singleton
+
+    class AdapterNotFoundError < StandardError; end
+    class DuplicateAdapterError < StandardError; end
+
+    def initialize
+      @adapters = Concurrent::Map.new
+    end
+
+    # Register a named adapter instance
+    #
+    # @param name [Symbol] Unique identifier for this adapter instance
+    # @param type [Symbol] The adapter type (e.g., :sentry, :appsignal)
+    # @param settings [Hash] Configuration for the adapter
+    # @return [Adapter] The registered adapter instance
+    def register(name, type, **settings)
+      name = name.to_sym
+
+      # Check if adapter already exists
+      raise DuplicateAdapterError, "Adapter '#{name}' already registered" if @adapters.key?(name)
+
+      adapter_class = resolve_adapter_class(type)
+      adapter = adapter_class.new(name, settings)
+      @adapters[name] = adapter
+      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
+    end
+
+    # Get a specific adapter by name
+    #
+    # @param name [Symbol] The adapter name
+    # @return [Adapter, nil] The adapter instance or nil
+    def [](name)
+      @adapters[name.to_sym]
+    end
+
+    # Get all registered adapters
+    #
+    # @return [Array<Adapter>] All adapter instances
+    def all
+      @adapters.values
+    end
+
+    # Get all active (enabled) adapters
+    #
+    # @return [Array<Adapter>] Active adapter instances
+    def active
+      @adapters.values.select(&:enabled?)
+    end
+
+    # Check if an adapter is registered
+    #
+    # @param name [Symbol] The adapter name
+    # @return [Boolean]
+    def registered?(name)
+      @adapters.key?(name.to_sym)
+    end
+
+    # Clear all adapters
+    def clear!
+      @adapters.values.each do |adapter|
+        adapter.shutdown if adapter.respond_to?(:shutdown)
+      end
+      @adapters.clear
+    end
+
+    # Get adapter names
+    #
+    # @return [Array<Symbol>] Registered adapter names
+    def names
+      @adapters.keys
+    end
+
+    private
+
+    # Resolve adapter type to class
+    def resolve_adapter_class(type)
+      adapter_map[type.to_sym] || raise(AdapterNotFoundError, "Unknown adapter type: #{type}")
+    end
+
+    # 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
+      }
+    end
+  end
+end

data/lib/lapsoss/release_tracker.rb

@@ -0,0 +1,553 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Lapsoss
+  # Release and version tracking system
+  class ReleaseTracker
+    def initialize(configuration = {})
+      @version_providers = configuration[:version_providers] || []
+      @git_enabled = configuration[:git_enabled] != false
+      @environment_enabled = configuration[:environment_enabled] != false
+      @deployment_enabled = configuration[:deployment_enabled] != false
+      @cache_duration = configuration[:cache_duration] || 300 # 5 minutes
+      @cached_release_info = nil
+      @cache_timestamp = nil
+    end
+
+    def get_release_info
+      now = Time.now
+
+      # Return cached info if still valid
+      if @cached_release_info && @cache_timestamp && (now - @cache_timestamp) < @cache_duration
+        return @cached_release_info
+      end
+
+      # Build fresh release info
+      release_info = {}
+
+      # Add custom version providers
+      @version_providers.each do |provider|
+        begin
+          if provider_info = provider.call
+            release_info.merge!(provider_info)
+          end
+        rescue StandardError => e
+          warn "Release provider failed: #{e.message}"
+        end
+      end
+
+      # Add Git information
+      if @git_enabled
+        if git_info = detect_git_info
+          release_info.merge!(git_info)
+        end
+      end
+
+      # Add environment information
+      if @environment_enabled
+        if env_info = detect_environment_info
+          release_info.merge!(env_info)
+        end
+      end
+
+      # Add deployment information
+      if @deployment_enabled
+        if deployment_info = detect_deployment_info
+          release_info.merge!(deployment_info)
+        end
+      end
+
+      # Generate release ID if not provided
+      release_info[:release_id] ||= generate_release_id(release_info)
+
+      # Cache the result
+      @cached_release_info = release_info
+      @cache_timestamp = now
+
+      release_info
+    end
+
+    def add_version_provider(&block)
+      @version_providers << block
+    end
+
+    def clear_cache
+      @cached_release_info = nil
+      @cache_timestamp = nil
+    end
+
+    private
+
+    def detect_git_info
+      return nil unless File.exist?(".git")
+
+      git_info = {}
+
+      begin
+        # Get current commit SHA
+        commit_sha = execute_git_command("rev-parse HEAD")
+        git_info[:commit_sha] = commit_sha if commit_sha
+
+        # Get short commit SHA
+        short_sha = execute_git_command("rev-parse --short HEAD")
+        git_info[:short_sha] = short_sha if short_sha
+
+        # Get branch name
+        branch = execute_git_command("rev-parse --abbrev-ref HEAD")
+        git_info[:branch] = branch if branch && branch != "HEAD"
+
+        # Get commit timestamp
+        commit_timestamp = execute_git_command("log -1 --format=%ct")
+        if commit_timestamp && !commit_timestamp.empty?
+          git_info[:commit_timestamp] = Time.at(commit_timestamp.to_i)
+        end
+
+        # Get commit message
+        commit_message = execute_git_command("log -1 --format=%s")
+        git_info[:commit_message] = commit_message if commit_message
+
+        # Get committer info
+        committer = execute_git_command("log -1 --format=%cn")
+        git_info[:committer] = committer if committer
+
+        # Get tag if on a tag
+        tag = execute_git_command("describe --exact-match --tags HEAD 2>/dev/null")
+        git_info[:tag] = tag if tag && !tag.empty?
+
+        # Get latest tag
+        latest_tag = execute_git_command("describe --tags --abbrev=0 2>/dev/null")
+        git_info[:latest_tag] = latest_tag if latest_tag && !latest_tag.empty?
+
+        # Get commits since latest tag
+        if latest_tag
+          commits_since_tag = execute_git_command("rev-list #{latest_tag}..HEAD --count")
+          git_info[:commits_since_tag] = commits_since_tag.to_i if commits_since_tag
+        end
+
+        # Check if working directory is dirty
+        git_status = execute_git_command("status --porcelain")
+        git_info[:dirty] = !git_status.empty? if git_status
+
+        # Get remote URL
+        remote_url = execute_git_command("config --get remote.origin.url")
+        if remote_url
+          git_info[:remote_url] = sanitize_remote_url(remote_url)
+        end
+
+        git_info
+      rescue StandardError => e
+        warn "Failed to detect Git info: #{e.message}"
+        nil
+      end
+    end
+
+    def detect_environment_info
+      env_info = {}
+
+      # Application version from common environment variables
+      env_info[:app_version] = ENV["APP_VERSION"] if ENV["APP_VERSION"]
+      env_info[:version] = ENV["VERSION"] if ENV["VERSION"]
+
+      # Environment detection
+      env_info[:environment] = detect_environment
+
+      # Application name
+      env_info[:app_name] = ENV["APP_NAME"] if ENV["APP_NAME"]
+
+      # Build information
+      env_info[:build_number] = ENV["BUILD_NUMBER"] if ENV["BUILD_NUMBER"]
+      env_info[:build_id] = ENV["BUILD_ID"] if ENV["BUILD_ID"]
+      env_info[:build_url] = ENV["BUILD_URL"] if ENV["BUILD_URL"]
+
+      # CI/CD information
+      env_info[:ci] = detect_ci_info
+
+      env_info.compact
+    end
+
+    def detect_deployment_info
+      deployment_info = {}
+
+      # Deployment timestamp
+      if ENV["DEPLOYMENT_TIME"]
+        deployment_info[:deployment_time] = parse_time(ENV["DEPLOYMENT_TIME"])
+      elsif ENV["DEPLOYED_AT"]
+        deployment_info[:deployment_time] = parse_time(ENV["DEPLOYED_AT"])
+      end
+
+      # Deployment ID
+      deployment_info[:deployment_id] = ENV["DEPLOYMENT_ID"] if ENV["DEPLOYMENT_ID"]
+
+      # Platform-specific detection
+      deployment_info.merge!(detect_heroku_info)
+      deployment_info.merge!(detect_aws_info)
+      deployment_info.merge!(detect_gcp_info)
+      deployment_info.merge!(detect_azure_info)
+      deployment_info.merge!(detect_docker_info)
+      deployment_info.merge!(detect_kubernetes_info)
+
+      deployment_info.compact
+    end
+
+    def detect_environment
+      return ENV["RAILS_ENV"] if ENV["RAILS_ENV"]
+      return ENV["RACK_ENV"] if ENV["RACK_ENV"]
+      return ENV["NODE_ENV"] if ENV["NODE_ENV"]
+      return ENV["ENVIRONMENT"] if ENV["ENVIRONMENT"]
+      return ENV["ENV"] if ENV["ENV"]
+
+      # Try to detect from Rails if available
+      if defined?(Rails) && Rails.respond_to?(:env)
+        return Rails.env.to_s
+      end
+
+      # Default fallback
+      "unknown"
+    end
+
+    def detect_ci_info
+      ci_info = {}
+
+      # GitHub Actions
+      if ENV["GITHUB_ACTIONS"]
+        ci_info[:provider] = "github_actions"
+        ci_info[:run_id] = ENV["GITHUB_RUN_ID"]
+        ci_info[:run_number] = ENV["GITHUB_RUN_NUMBER"]
+        ci_info[:workflow] = ENV["GITHUB_WORKFLOW"]
+        ci_info[:actor] = ENV["GITHUB_ACTOR"]
+        ci_info[:repository] = ENV["GITHUB_REPOSITORY"]
+        ci_info[:ref] = ENV["GITHUB_REF"]
+        ci_info[:sha] = ENV["GITHUB_SHA"]
+      end
+
+      # GitLab CI
+      if ENV["GITLAB_CI"]
+        ci_info[:provider] = "gitlab_ci"
+        ci_info[:pipeline_id] = ENV["CI_PIPELINE_ID"]
+        ci_info[:job_id] = ENV["CI_JOB_ID"]
+        ci_info[:job_name] = ENV["CI_JOB_NAME"]
+        ci_info[:commit_sha] = ENV["CI_COMMIT_SHA"]
+        ci_info[:commit_ref] = ENV["CI_COMMIT_REF_NAME"]
+        ci_info[:project_url] = ENV["CI_PROJECT_URL"]
+      end
+
+      # Jenkins
+      if ENV["JENKINS_URL"]
+        ci_info[:provider] = "jenkins"
+        ci_info[:build_number] = ENV["BUILD_NUMBER"]
+        ci_info[:build_id] = ENV["BUILD_ID"]
+        ci_info[:job_name] = ENV["JOB_NAME"]
+        ci_info[:build_url] = ENV["BUILD_URL"]
+        ci_info[:git_commit] = ENV["GIT_COMMIT"]
+        ci_info[:git_branch] = ENV["GIT_BRANCH"]
+      end
+
+      # CircleCI
+      if ENV["CIRCLECI"]
+        ci_info[:provider] = "circleci"
+        ci_info[:build_num] = ENV["CIRCLE_BUILD_NUM"]
+        ci_info[:workflow_id] = ENV["CIRCLE_WORKFLOW_ID"]
+        ci_info[:job] = ENV["CIRCLE_JOB"]
+        ci_info[:project_reponame] = ENV["CIRCLE_PROJECT_REPONAME"]
+        ci_info[:sha1] = ENV["CIRCLE_SHA1"]
+        ci_info[:branch] = ENV["CIRCLE_BRANCH"]
+      end
+
+      # Travis CI
+      if ENV["TRAVIS"]
+        ci_info[:provider] = "travis"
+        ci_info[:build_id] = ENV["TRAVIS_BUILD_ID"]
+        ci_info[:build_number] = ENV["TRAVIS_BUILD_NUMBER"]
+        ci_info[:job_id] = ENV["TRAVIS_JOB_ID"]
+        ci_info[:commit] = ENV["TRAVIS_COMMIT"]
+        ci_info[:branch] = ENV["TRAVIS_BRANCH"]
+        ci_info[:tag] = ENV["TRAVIS_TAG"]
+      end
+
+      ci_info
+    end
+
+    def detect_heroku_info
+      return {} unless ENV["HEROKU_APP_NAME"]
+
+      {
+        platform: "heroku",
+        app_name: ENV["HEROKU_APP_NAME"],
+        dyno: ENV["DYNO"],
+        slug_commit: ENV["HEROKU_SLUG_COMMIT"],
+        release_version: ENV["HEROKU_RELEASE_VERSION"],
+        slug_description: ENV["HEROKU_SLUG_DESCRIPTION"]
+      }
+    end
+
+    def detect_aws_info
+      info = {}
+
+      if ENV["AWS_EXECUTION_ENV"]
+        info[:platform] = "aws"
+        info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
+        info[:region] = ENV["AWS_REGION"] || ENV["AWS_DEFAULT_REGION"]
+        info[:function_name] = ENV["AWS_LAMBDA_FUNCTION_NAME"]
+        info[:function_version] = ENV["AWS_LAMBDA_FUNCTION_VERSION"]
+      end
+
+      # EC2 metadata (if available)
+      if ENV["EC2_INSTANCE_ID"]
+        info[:platform] = "aws_ec2"
+        info[:instance_id] = ENV["EC2_INSTANCE_ID"]
+        info[:instance_type] = ENV["EC2_INSTANCE_TYPE"]
+        info[:availability_zone] = ENV["EC2_AVAILABILITY_ZONE"]
+      end
+
+      info
+    end
+
+    def detect_gcp_info
+      info = {}
+
+      if ENV["GOOGLE_CLOUD_PROJECT"]
+        info[:platform] = "gcp"
+        info[:project] = ENV["GOOGLE_CLOUD_PROJECT"]
+        info[:region] = ENV["GOOGLE_CLOUD_REGION"]
+        info[:function_name] = ENV["FUNCTION_NAME"]
+        info[:function_signature_type] = ENV["FUNCTION_SIGNATURE_TYPE"]
+      end
+
+      # App Engine
+      if ENV["GAE_APPLICATION"]
+        info[:platform] = "gcp_app_engine"
+        info[:application] = ENV["GAE_APPLICATION"]
+        info[:service] = ENV["GAE_SERVICE"]
+        info[:version] = ENV["GAE_VERSION"]
+        info[:runtime] = ENV["GAE_RUNTIME"]
+      end
+
+      info
+    end
+
+    def detect_azure_info
+      info = {}
+
+      if ENV["WEBSITE_SITE_NAME"]
+        info[:platform] = "azure"
+        info[:site_name] = ENV["WEBSITE_SITE_NAME"]
+        info[:resource_group] = ENV["WEBSITE_RESOURCE_GROUP"]
+        info[:subscription_id] = ENV["WEBSITE_OWNER_NAME"]
+        info[:sku] = ENV["WEBSITE_SKU"]
+      end
+
+      info
+    end
+
+    def detect_docker_info
+      info = {}
+
+      if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
+        info[:platform] = "docker"
+        info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
+        info[:image] = ENV["DOCKER_IMAGE"]
+        info[:tag] = ENV["DOCKER_TAG"]
+      end
+
+      info
+    end
+
+    def detect_kubernetes_info
+      info = {}
+
+      if ENV["KUBERNETES_SERVICE_HOST"]
+        info[:platform] = "kubernetes"
+        info[:namespace] = ENV["KUBERNETES_NAMESPACE"]
+        info[:pod_name] = ENV["HOSTNAME"]
+        info[:service_account] = ENV["KUBERNETES_SERVICE_ACCOUNT"]
+        info[:cluster_name] = ENV["CLUSTER_NAME"]
+        info[:node_name] = ENV["NODE_NAME"]
+      end
+
+      info
+    end
+
+    def execute_git_command(command)
+      result = `git #{command} 2>/dev/null`.strip
+      result.empty? ? nil : result
+    rescue StandardError
+      nil
+    end
+
+    def sanitize_remote_url(url)
+      # Remove credentials from Git URLs
+      url.gsub(%r{://[^@/]+@}, "://")
+    end
+
+    def parse_time(time_str)
+      return nil unless time_str
+
+      # Try different time formats
+      formats = [
+        "%Y-%m-%dT%H:%M:%S%z",      # ISO 8601 with timezone
+        "%Y-%m-%dT%H:%M:%SZ",       # ISO 8601 UTC
+        "%Y-%m-%d %H:%M:%S %z",     # Standard format with timezone
+        "%Y-%m-%d %H:%M:%S",        # Standard format without timezone
+        "%s"                        # Unix timestamp
+      ]
+
+      formats.each do |format|
+        begin
+          return Time.strptime(time_str, format)
+        rescue ArgumentError
+          next
+        end
+      end
+
+      # Try parsing as integer (Unix timestamp)
+      begin
+        return Time.at(time_str.to_i) if time_str.match?(/^\d+$/)
+      rescue ArgumentError
+        nil
+      end
+
+      nil
+    end
+
+    def generate_release_id(release_info)
+      # Generate a unique release ID based on available information
+      components = []
+
+      # Prioritize version-like information
+      components << release_info[:app_version] if release_info[:app_version]
+      components << release_info[:version] if release_info[:version]
+      components << release_info[:tag] if release_info[:tag]
+      components << release_info[:short_sha] if release_info[:short_sha]
+      components << release_info[:commit_sha] if release_info[:commit_sha] && components.empty?
+
+      # Add environment if available
+      components << release_info[:environment] if release_info[:environment]
+
+      # Add deployment ID if available
+      components << release_info[:deployment_id] if release_info[:deployment_id]
+
+      # If we have components, join them
+      if components.any?
+        release_id = components.join("-")
+        # Truncate if too long
+        release_id.length > 64 ? release_id[0, 64] : release_id
+      else
+        # Generate hash from all available info
+        info_string = release_info.to_s
+        Digest::SHA256.hexdigest(info_string)[0, 8]
+      end
+    end
+  end
+
+  # 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
+        begin
+          constant = Object.const_get(constant_name)
+          { version: constant.to_s }
+        rescue NameError
+          nil
+        end
+      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
+        if app.class.respond_to?(:version)
+          info[:app_version] = app.class.version
+        end
+
+        # Get application name
+        if app.class.respond_to?(:name)
+          info[:app_name] = app.class.name
+        end
+
+        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

data/lib/lapsoss/router.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class Router
+    class << self
+      # Processes an event by dispatching it to all active adapters.
+      # The actual dispatch (sync/async) is handled by the Client.
+      #
+      # @param event [Lapsoss::Event] The event to process.
+      def process_event(event)
+        Registry.instance.active.each do |adapter|
+          begin
+            adapter.capture(event)
+          rescue => e
+            handle_adapter_error(adapter, event, e)
+          end
+        end
+      end
+
+      private
+
+      # Handle adapter errors gracefully
+      def handle_adapter_error(adapter, event, error)
+        return unless Lapsoss.configuration.logger
+
+        Lapsoss.configuration.logger.error(
+          "[Lapsoss] Adapter '#{adapter.name}' failed to capture event (type: #{event.type}): #{error.message}"
+        )
+
+        # Call error handler if configured
+        handler = Lapsoss.configuration.error_handler
+        handler&.call(adapter, event, error)
+      end
+    end
+  end
+end