lapsoss 0.2.0 → 0.3.0

data/lib/lapsoss/release_tracker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Lapsoss
   # Release and version tracking system
@@ -13,6 +13,9 @@ module Lapsoss
       @cache_duration = configuration[:cache_duration] || 300 # 5 minutes
       @cached_release_info = nil
       @cache_timestamp = nil
+
+      # Auto-register rails_app_version provider if available
+      add_rails_app_version_provider if defined?(Rails) && Rails.application.respond_to?(:version)
     end
 
     def get_release_info
@@ -69,44 +72,57 @@ module Lapsoss
       @cache_timestamp = nil
     end
 
+    def add_rails_app_version_provider
+      add_version_provider do
+        if defined?(Rails) && Rails.application.respond_to?(:version)
+          version = Rails.application.version
+          {
+            rails_app_version: version.to_s,
+            rails_app_version_cache_key: version.to_cache_key,
+            rails_app_environment: Rails.application.env
+          }
+        end
+      end
+    end
+
     private
 
     def detect_git_info
-      return nil unless File.exist?('.git')
+      return nil unless File.exist?(".git")
 
       git_info = {}
 
       begin
         # Get current commit SHA
-        commit_sha = execute_git_command('rev-parse HEAD')
+        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')
+        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'
+        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')
+        commit_timestamp = execute_git_command("log -1 --format=%ct")
         git_info[:commit_timestamp] = Time.zone.at(commit_timestamp.to_i) if commit_timestamp.present?
 
         # Get commit message
-        commit_message = execute_git_command('log -1 --format=%s')
+        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')
+        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')
+        tag = execute_git_command("describe --exact-match --tags HEAD 2>/dev/null")
         git_info[:tag] = tag if tag.present?
 
         # Get latest tag
-        latest_tag = execute_git_command('describe --tags --abbrev=0 2>/dev/null')
+        latest_tag = execute_git_command("describe --tags --abbrev=0 2>/dev/null")
         git_info[:latest_tag] = latest_tag if latest_tag.present?
 
         # Get commits since latest tag
@@ -116,11 +132,11 @@ module Lapsoss
         end
 
         # Check if working directory is dirty
-        git_status = execute_git_command('status --porcelain')
+        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')
+        remote_url = execute_git_command("config --get remote.origin.url")
         git_info[:remote_url] = sanitize_remote_url(remote_url) if remote_url
 
         git_info
@@ -133,20 +149,33 @@ module Lapsoss
     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']
+      # Try rails_app_version first if available
+      if defined?(Rails) && Rails.application.respond_to?(:version)
+        env_info[:version] = Rails.application.version.to_s
+        env_info[:app_version] = Rails.application.version.to_s
+
+        # Add detailed version info
+        version_obj = Rails.application.version
+        env_info[:version_major] = version_obj.major
+        env_info[:version_minor] = version_obj.minor
+        env_info[:version_patch] = version_obj.patch
+        env_info[:version_prerelease] = version_obj.prerelease? if version_obj.respond_to?(:prerelease?)
+      else
+        # Fallback to environment variables
+        env_info[:app_version] = ENV["APP_VERSION"] if ENV["APP_VERSION"]
+        env_info[:version] = ENV["VERSION"] if ENV["VERSION"]
+      end
 
       # Environment detection
       env_info[:environment] = detect_environment
 
       # Application name
-      env_info[:app_name] = ENV['APP_NAME'] if ENV['APP_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']
+      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
@@ -158,14 +187,14 @@ module Lapsoss
       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'])
+      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']
+      deployment_info[:deployment_id] = ENV["DEPLOYMENT_ID"] if ENV["DEPLOYMENT_ID"]
 
       # Platform-specific detection
       deployment_info.merge!(detect_heroku_info)
@@ -179,111 +208,114 @@ module Lapsoss
     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 rails_app_version first if available
+      return Rails.application.env if defined?(Rails) && Rails.application.respond_to?(:env)
+
+      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
       return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
 
       # Default fallback
-      'unknown'
+      "unknown"
     end
 
     def detect_ci_info
       ci_info = {}
 
       # GitHub Actions
-      if ENV['GITHUB_ACTIONS']
-        ci_info[:provider] = 'github_actions'
-        ci_info[:run_id] = ENV.fetch('GITHUB_RUN_ID', nil)
-        ci_info[:run_number] = ENV.fetch('GITHUB_RUN_NUMBER', nil)
-        ci_info[:workflow] = ENV.fetch('GITHUB_WORKFLOW', nil)
-        ci_info[:actor] = ENV.fetch('GITHUB_ACTOR', nil)
-        ci_info[:repository] = ENV.fetch('GITHUB_REPOSITORY', nil)
-        ci_info[:ref] = ENV.fetch('GITHUB_REF', nil)
-        ci_info[:sha] = ENV.fetch('GITHUB_SHA', nil)
+      if ENV["GITHUB_ACTIONS"]
+        ci_info[:provider] = "github_actions"
+        ci_info[:run_id] = ENV.fetch("GITHUB_RUN_ID", nil)
+        ci_info[:run_number] = ENV.fetch("GITHUB_RUN_NUMBER", nil)
+        ci_info[:workflow] = ENV.fetch("GITHUB_WORKFLOW", nil)
+        ci_info[:actor] = ENV.fetch("GITHUB_ACTOR", nil)
+        ci_info[:repository] = ENV.fetch("GITHUB_REPOSITORY", nil)
+        ci_info[:ref] = ENV.fetch("GITHUB_REF", nil)
+        ci_info[:sha] = ENV.fetch("GITHUB_SHA", nil)
       end
 
       # GitLab CI
-      if ENV['GITLAB_CI']
-        ci_info[:provider] = 'gitlab_ci'
-        ci_info[:pipeline_id] = ENV.fetch('CI_PIPELINE_ID', nil)
-        ci_info[:job_id] = ENV.fetch('CI_JOB_ID', nil)
-        ci_info[:job_name] = ENV.fetch('CI_JOB_NAME', nil)
-        ci_info[:commit_sha] = ENV.fetch('CI_COMMIT_SHA', nil)
-        ci_info[:commit_ref] = ENV.fetch('CI_COMMIT_REF_NAME', nil)
-        ci_info[:project_url] = ENV.fetch('CI_PROJECT_URL', nil)
+      if ENV["GITLAB_CI"]
+        ci_info[:provider] = "gitlab_ci"
+        ci_info[:pipeline_id] = ENV.fetch("CI_PIPELINE_ID", nil)
+        ci_info[:job_id] = ENV.fetch("CI_JOB_ID", nil)
+        ci_info[:job_name] = ENV.fetch("CI_JOB_NAME", nil)
+        ci_info[:commit_sha] = ENV.fetch("CI_COMMIT_SHA", nil)
+        ci_info[:commit_ref] = ENV.fetch("CI_COMMIT_REF_NAME", nil)
+        ci_info[:project_url] = ENV.fetch("CI_PROJECT_URL", nil)
       end
 
       # Jenkins
-      if ENV['JENKINS_URL']
-        ci_info[:provider] = 'jenkins'
-        ci_info[:build_number] = ENV.fetch('BUILD_NUMBER', nil)
-        ci_info[:build_id] = ENV.fetch('BUILD_ID', nil)
-        ci_info[:job_name] = ENV.fetch('JOB_NAME', nil)
-        ci_info[:build_url] = ENV.fetch('BUILD_URL', nil)
-        ci_info[:git_commit] = ENV.fetch('GIT_COMMIT', nil)
-        ci_info[:git_branch] = ENV.fetch('GIT_BRANCH', nil)
+      if ENV["JENKINS_URL"]
+        ci_info[:provider] = "jenkins"
+        ci_info[:build_number] = ENV.fetch("BUILD_NUMBER", nil)
+        ci_info[:build_id] = ENV.fetch("BUILD_ID", nil)
+        ci_info[:job_name] = ENV.fetch("JOB_NAME", nil)
+        ci_info[:build_url] = ENV.fetch("BUILD_URL", nil)
+        ci_info[:git_commit] = ENV.fetch("GIT_COMMIT", nil)
+        ci_info[:git_branch] = ENV.fetch("GIT_BRANCH", nil)
       end
 
       # CircleCI
-      if ENV['CIRCLECI']
-        ci_info[:provider] = 'circleci'
-        ci_info[:build_num] = ENV.fetch('CIRCLE_BUILD_NUM', nil)
-        ci_info[:workflow_id] = ENV.fetch('CIRCLE_WORKFLOW_ID', nil)
-        ci_info[:job] = ENV.fetch('CIRCLE_JOB', nil)
-        ci_info[:project_reponame] = ENV.fetch('CIRCLE_PROJECT_REPONAME', nil)
-        ci_info[:sha1] = ENV.fetch('CIRCLE_SHA1', nil)
-        ci_info[:branch] = ENV.fetch('CIRCLE_BRANCH', nil)
+      if ENV["CIRCLECI"]
+        ci_info[:provider] = "circleci"
+        ci_info[:build_num] = ENV.fetch("CIRCLE_BUILD_NUM", nil)
+        ci_info[:workflow_id] = ENV.fetch("CIRCLE_WORKFLOW_ID", nil)
+        ci_info[:job] = ENV.fetch("CIRCLE_JOB", nil)
+        ci_info[:project_reponame] = ENV.fetch("CIRCLE_PROJECT_REPONAME", nil)
+        ci_info[:sha1] = ENV.fetch("CIRCLE_SHA1", nil)
+        ci_info[:branch] = ENV.fetch("CIRCLE_BRANCH", nil)
       end
 
       # Travis CI
-      if ENV['TRAVIS']
-        ci_info[:provider] = 'travis'
-        ci_info[:build_id] = ENV.fetch('TRAVIS_BUILD_ID', nil)
-        ci_info[:build_number] = ENV.fetch('TRAVIS_BUILD_NUMBER', nil)
-        ci_info[:job_id] = ENV.fetch('TRAVIS_JOB_ID', nil)
-        ci_info[:commit] = ENV.fetch('TRAVIS_COMMIT', nil)
-        ci_info[:branch] = ENV.fetch('TRAVIS_BRANCH', nil)
-        ci_info[:tag] = ENV.fetch('TRAVIS_TAG', nil)
+      if ENV["TRAVIS"]
+        ci_info[:provider] = "travis"
+        ci_info[:build_id] = ENV.fetch("TRAVIS_BUILD_ID", nil)
+        ci_info[:build_number] = ENV.fetch("TRAVIS_BUILD_NUMBER", nil)
+        ci_info[:job_id] = ENV.fetch("TRAVIS_JOB_ID", nil)
+        ci_info[:commit] = ENV.fetch("TRAVIS_COMMIT", nil)
+        ci_info[:branch] = ENV.fetch("TRAVIS_BRANCH", nil)
+        ci_info[:tag] = ENV.fetch("TRAVIS_TAG", nil)
       end
 
       ci_info
     end
 
     def detect_heroku_info
-      return {} unless ENV['HEROKU_APP_NAME']
+      return {} unless ENV["HEROKU_APP_NAME"]
 
       {
-        platform: 'heroku',
-        app_name: ENV.fetch('HEROKU_APP_NAME', nil),
-        dyno: ENV.fetch('DYNO', nil),
-        slug_commit: ENV.fetch('HEROKU_SLUG_COMMIT', nil),
-        release_version: ENV.fetch('HEROKU_RELEASE_VERSION', nil),
-        slug_description: ENV.fetch('HEROKU_SLUG_DESCRIPTION', nil)
+        platform: "heroku",
+        app_name: ENV.fetch("HEROKU_APP_NAME", nil),
+        dyno: ENV.fetch("DYNO", nil),
+        slug_commit: ENV.fetch("HEROKU_SLUG_COMMIT", nil),
+        release_version: ENV.fetch("HEROKU_RELEASE_VERSION", nil),
+        slug_description: ENV.fetch("HEROKU_SLUG_DESCRIPTION", nil)
       }
     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.fetch('AWS_DEFAULT_REGION', nil)
-        info[:function_name] = ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)
-        info[:function_version] = ENV.fetch('AWS_LAMBDA_FUNCTION_VERSION', nil)
+      if ENV["AWS_EXECUTION_ENV"]
+        info[:platform] = "aws"
+        info[:execution_env] = ENV["AWS_EXECUTION_ENV"]
+        info[:region] = ENV["AWS_REGION"] || ENV.fetch("AWS_DEFAULT_REGION", nil)
+        info[:function_name] = ENV.fetch("AWS_LAMBDA_FUNCTION_NAME", nil)
+        info[:function_version] = ENV.fetch("AWS_LAMBDA_FUNCTION_VERSION", nil)
       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.fetch('EC2_INSTANCE_TYPE', nil)
-        info[:availability_zone] = ENV.fetch('EC2_AVAILABILITY_ZONE', nil)
+      if ENV["EC2_INSTANCE_ID"]
+        info[:platform] = "aws_ec2"
+        info[:instance_id] = ENV["EC2_INSTANCE_ID"]
+        info[:instance_type] = ENV.fetch("EC2_INSTANCE_TYPE", nil)
+        info[:availability_zone] = ENV.fetch("EC2_AVAILABILITY_ZONE", nil)
       end
 
       info
@@ -292,21 +324,21 @@ module Lapsoss
     def detect_gcp_info
       info = {}
 
-      if ENV['GOOGLE_CLOUD_PROJECT']
-        info[:platform] = 'gcp'
-        info[:project] = ENV['GOOGLE_CLOUD_PROJECT']
-        info[:region] = ENV.fetch('GOOGLE_CLOUD_REGION', nil)
-        info[:function_name] = ENV.fetch('FUNCTION_NAME', nil)
-        info[:function_signature_type] = ENV.fetch('FUNCTION_SIGNATURE_TYPE', nil)
+      if ENV["GOOGLE_CLOUD_PROJECT"]
+        info[:platform] = "gcp"
+        info[:project] = ENV["GOOGLE_CLOUD_PROJECT"]
+        info[:region] = ENV.fetch("GOOGLE_CLOUD_REGION", nil)
+        info[:function_name] = ENV.fetch("FUNCTION_NAME", nil)
+        info[:function_signature_type] = ENV.fetch("FUNCTION_SIGNATURE_TYPE", nil)
       end
 
       # App Engine
-      if ENV['GAE_APPLICATION']
-        info[:platform] = 'gcp_app_engine'
-        info[:application] = ENV['GAE_APPLICATION']
-        info[:service] = ENV.fetch('GAE_SERVICE', nil)
-        info[:version] = ENV.fetch('GAE_VERSION', nil)
-        info[:runtime] = ENV.fetch('GAE_RUNTIME', nil)
+      if ENV["GAE_APPLICATION"]
+        info[:platform] = "gcp_app_engine"
+        info[:application] = ENV["GAE_APPLICATION"]
+        info[:service] = ENV.fetch("GAE_SERVICE", nil)
+        info[:version] = ENV.fetch("GAE_VERSION", nil)
+        info[:runtime] = ENV.fetch("GAE_RUNTIME", nil)
       end
 
       info
@@ -315,12 +347,12 @@ module Lapsoss
     def detect_azure_info
       info = {}
 
-      if ENV['WEBSITE_SITE_NAME']
-        info[:platform] = 'azure'
-        info[:site_name] = ENV['WEBSITE_SITE_NAME']
-        info[:resource_group] = ENV.fetch('WEBSITE_RESOURCE_GROUP', nil)
-        info[:subscription_id] = ENV.fetch('WEBSITE_OWNER_NAME', nil)
-        info[:sku] = ENV.fetch('WEBSITE_SKU', nil)
+      if ENV["WEBSITE_SITE_NAME"]
+        info[:platform] = "azure"
+        info[:site_name] = ENV["WEBSITE_SITE_NAME"]
+        info[:resource_group] = ENV.fetch("WEBSITE_RESOURCE_GROUP", nil)
+        info[:subscription_id] = ENV.fetch("WEBSITE_OWNER_NAME", nil)
+        info[:sku] = ENV.fetch("WEBSITE_SKU", nil)
       end
 
       info
@@ -329,11 +361,11 @@ module Lapsoss
     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.fetch('DOCKER_IMAGE', nil)
-        info[:tag] = ENV.fetch('DOCKER_TAG', nil)
+      if ENV["DOCKER_CONTAINER_ID"] || File.exist?("/.dockerenv")
+        info[:platform] = "docker"
+        info[:container_id] = ENV["DOCKER_CONTAINER_ID"]
+        info[:image] = ENV.fetch("DOCKER_IMAGE", nil)
+        info[:tag] = ENV.fetch("DOCKER_TAG", nil)
       end
 
       info
@@ -342,13 +374,13 @@ module Lapsoss
     def detect_kubernetes_info
       info = {}
 
-      if ENV['KUBERNETES_SERVICE_HOST']
-        info[:platform] = 'kubernetes'
-        info[:namespace] = ENV.fetch('KUBERNETES_NAMESPACE', nil)
-        info[:pod_name] = ENV.fetch('HOSTNAME', nil)
-        info[:service_account] = ENV.fetch('KUBERNETES_SERVICE_ACCOUNT', nil)
-        info[:cluster_name] = ENV.fetch('CLUSTER_NAME', nil)
-        info[:node_name] = ENV.fetch('NODE_NAME', nil)
+      if ENV["KUBERNETES_SERVICE_HOST"]
+        info[:platform] = "kubernetes"
+        info[:namespace] = ENV.fetch("KUBERNETES_NAMESPACE", nil)
+        info[:pod_name] = ENV.fetch("HOSTNAME", nil)
+        info[:service_account] = ENV.fetch("KUBERNETES_SERVICE_ACCOUNT", nil)
+        info[:cluster_name] = ENV.fetch("CLUSTER_NAME", nil)
+        info[:node_name] = ENV.fetch("NODE_NAME", nil)
       end
 
       info
@@ -363,7 +395,7 @@ module Lapsoss
 
     def sanitize_remote_url(url)
       # Remove credentials from Git URLs
-      url.gsub(%r{://[^@/]+@}, '://')
+      url.gsub(%r{://[^@/]+@}, "://")
     end
 
     def parse_time(time_str)
@@ -371,11 +403,11 @@ module Lapsoss
 
       # 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
+        "%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|
@@ -413,7 +445,7 @@ module Lapsoss
 
       # If we have components, join them
       if components.any?
-        release_id = components.join('-')
+        release_id = components.join("-")
         # Truncate if too long
         release_id.length > 64 ? release_id[0, 64] : release_id
       else
@@ -423,109 +455,4 @@ module Lapsoss
       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
-        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

data/lib/lapsoss/sampling/adaptive_sampler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class AdaptiveSampler < Base
+      def initialize(target_rate: 1.0, adjustment_period: 60)
+        @target_rate = target_rate
+        @adjustment_period = adjustment_period
+        @current_rate = target_rate
+        @events_count = 0
+        @last_adjustment = Time.zone.now
+        @mutex = Mutex.new
+      end
+
+      def sample?(_event, _hint = {})
+        @mutex.synchronize do
+          @events_count += 1
+
+          # Adjust rate periodically
+          now = Time.zone.now
+          if now - @last_adjustment > @adjustment_period
+            adjust_rate
+            @last_adjustment = now
+            @events_count = 0
+          end
+        end
+
+        @current_rate > rand
+      end
+
+      attr_reader :current_rate
+
+      private
+
+      def adjust_rate
+        # Simple adaptive logic - can be enhanced based on system metrics
+        # For now, just ensure we don't drift too far from target
+        if @events_count > 100 # High volume
+          @current_rate = [ @current_rate * 0.9, @target_rate * 0.1 ].max
+        elsif @events_count < 10 # Low volume
+          @current_rate = [ @current_rate * 1.1, @target_rate ].min
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class Base
+      def sample?(_event, _hint = {})
+        true
+      end
+    end
+  end
+end

data/lib/lapsoss/sampling/composite_sampler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Sampling
+    class CompositeSampler < Base
+      def initialize(app = nil, samplers: [], strategy: :all)
+        @app = app
+        @samplers = samplers
+        @strategy = strategy
+      end
+
+      def sample?(event, hint = {})
+        case @strategy
+        when :all
+          @samplers.all? { |sampler| sampler.sample?(event, hint) }
+        when :any
+          @samplers.any? { |sampler| sampler.sample?(event, hint) }
+        when :first
+          @samplers.first&.sample?(event, hint) || true
+        else
+          raise ArgumentError, "Unknown strategy: #{@strategy}"
+        end
+      end
+    end
+  end
+end