rails_mind 0.1.0

data/lib/rails_mind/integrations/rails.rb

@@ -0,0 +1,120 @@
+require "active_support/notifications"
+require "digest"
+
+module RailsMind
+  module Integrations
+    class ErrorSubscriber
+      def report(error, handled:, severity:, context:, source: nil, **options)
+        RailsMind.capture_exception(error, handled: handled, severity: severity, context: context, source: source)
+      end
+    end
+
+    class RequestContext
+      def initialize(app) = @app = app
+
+      def call(env)
+        Context.with(request_id: env["action_dispatch.request_id"] || SecureRandom.uuid) do
+          previous = Thread.current[:rails_mind_queries]
+          Thread.current[:rails_mind_queries] = { count: 0, fingerprints: Hash.new(0) }
+          @app.call(env)
+        rescue StandardError => error
+          # Preserve identity before this request boundary unwinds. The Rails
+          # reporter may observe the same exception later; object dedup prevents
+          # a second RailsMind event while other reporters remain unaffected.
+          RailsMind.capture_exception(error, source: "rack")
+          raise
+        ensure
+          Thread.current[:rails_mind_queries] = previous
+        end
+      end
+    end
+
+    module JobContext
+      def self.included(base)
+        base.around_enqueue do |job, block|
+          job.rails_mind_context = Context.snapshot.transform_keys(&:to_s)
+          block.call
+        end
+        base.around_perform do |job, block|
+          job.rails_mind_started_at = Time.now
+          Context.with((job.rails_mind_context || {}).merge("job_id" => job.job_id)) { block.call }
+        end
+      end
+
+      attr_accessor :rails_mind_context, :rails_mind_started_at
+
+      def serialize = super.merge("rails_mind_context" => rails_mind_context || {})
+
+      def deserialize(job_data)
+        super
+        self.rails_mind_context = (job_data["rails_mind_context"] || {}).slice(*Context::KEYS.map(&:to_s))
+      end
+    end
+
+    module RailsNotifications
+      class << self
+        def install!
+          return if @subscriptions
+          @subscriptions = []
+          subscribe("process_action.action_controller") do |event|
+            payload = event.payload
+            queries = Thread.current[:rails_mind_queries]
+            counts = queries&.fetch(:fingerprints, {}) || {}
+            status = payload[:status] || (payload[:exception] ? 500 : 200)
+            RailsMind.client.emit(:request, "#{payload[:controller]}##{payload[:action]}", duration_ms: event.duration,
+              status: status.to_s, properties: { controller: payload[:controller], action: payload[:action],
+                method: payload[:method], view_runtime: payload[:view_runtime], db_runtime: payload[:db_runtime],
+                query_count: queries&.fetch(:count), repeated_query_count: counts.values.sum { |n| [ n - 1, 0 ].max },
+                query_fingerprints: counts.sort_by { |_, count| -count }.first(10).to_h })
+          end
+          subscribe("sql.active_record") do |event|
+            queries = Thread.current[:rails_mind_queries]
+            next unless queries && !event.payload[:cached] && !%w[SCHEMA TRANSACTION].include?(event.payload[:name])
+            queries[:count] += 1
+            # Normalize locally, transmit only one-way hashes; never SQL or binds.
+            normalized = event.payload[:sql].to_s[0, 16_384].gsub(/'(?:[^']|'')*'/, "?").gsub(/\b\d+\b/, "?").gsub(/\s+/, " ")
+            fingerprint = Digest::SHA256.hexdigest(normalized)[0, 24]
+            queries[:fingerprints][fingerprint] += 1 if queries[:fingerprints].key?(fingerprint) || queries[:fingerprints].size < 100
+          end
+          %w[perform.active_job enqueue_retry.active_job retry_stopped.active_job discard.active_job].each do |name|
+            subscribe(name) do |event|
+              job = event.payload[:job]
+              next unless job
+              error = event.payload[:exception_object] || event.payload[:error]
+              Context.with((job.rails_mind_context || {}).merge("job_id" => job.job_id)) do
+                RailsMind.client.emit(:job, job.class.name, duration_ms: event.duration,
+                  status: error ? "error" : (name == "perform.active_job" ? "ok" : name.split(".").first),
+                  properties: { operation: name.split(".").first, queue: job.queue_name, executions: job.executions,
+                    queue_delay_ms: job.enqueued_at && job.rails_mind_started_at ? [ (job.rails_mind_started_at.to_f - job.enqueued_at.to_f) * 1000, 0 ].max : nil })
+                RailsMind.capture_exception(error, source: "active_job") if error
+              end
+            end
+          end
+          subscribe("feature_operation.flipper") do |event|
+            payload = event.payload
+            operation = payload[:operation].to_s
+            result = payload[:result]
+            RailsMind.client.emit(:flag, payload[:feature_name].to_s, duration_ms: event.duration,
+              properties: { operation: operation, enabled: result == true ? true : (result == false ? false : nil),
+                exposure: false })
+          end
+        end
+
+        def uninstall!
+          @subscriptions&.each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+          @subscriptions = nil
+        end
+
+        private
+
+        def subscribe(name, &callback)
+          @subscriptions << ActiveSupport::Notifications.subscribe(name) do |event|
+            callback.call(event) unless Context.suppressed?
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_mind/railtie.rb

@@ -0,0 +1,20 @@
+require_relative "integrations/rails"
+
+module RailsMind
+  class Railtie < Rails::Railtie
+    initializer "rails_mind.request_context" do |app|
+      app.middleware.insert_after ActionDispatch::RequestId, Integrations::RequestContext
+    end
+
+    config.after_initialize do
+      Integrations::RailsNotifications.install!
+      Rails.error.subscribe(Integrations::ErrorSubscriber.new)
+      ActiveSupport.on_load(:active_job) do
+        include Integrations::JobContext unless included_modules.include?(Integrations::JobContext)
+      end
+      at_exit { RailsMind.shutdown }
+    end
+
+    rake_tasks { load File.expand_path("../tasks/rails_mind.rake", __dir__) }
+  end
+end

data/lib/rails_mind/redactor.rb

@@ -0,0 +1,32 @@
+module RailsMind
+  class Redactor
+    FILTER = /password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|authorization|cookie|credential|session|email|phone|address|credit|card|body|params|arguments|bind|sql|db\.statement|query\.text/i
+    MAX_STRING = 1024
+
+    def call(value, depth = 0)
+      return "[TRUNCATED]" if depth > 5
+      case value
+      when Hash
+        value.first(50).to_h.transform_keys { |key| key.to_s[0, 100] }.each_with_object({}) do |(key, item), clean|
+          clean[key] = key.match?(FILTER) ? "[FILTERED]" : call(item, depth + 1)
+        end
+      when Array then value.first(50).map { |item| call(item, depth + 1) }
+      when String then scrub(value)
+      when Integer, TrueClass, FalseClass, NilClass then value
+      when Float then value.finite? ? value : nil
+      when Symbol then scrub(value.to_s)
+      else nil # Never call #inspect on application objects.
+      end
+    end
+
+    def scrub(value)
+      value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "�")
+        .gsub(/\b[A-Z0-9._%+\-]+@[A-Z0-9.\-]+\.[A-Z]{2,}\b/i, "[EMAIL]")
+        .gsub(/\bBearer\s+\S+/i, "Bearer [FILTERED]")
+        .gsub(/((?:password|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|authorization)\s*[=:]\s*)[^\s,;&]+/i, '\\1[FILTERED]')
+        .gsub(%r{(https?://)[^\s/@]+:[^\s/@]+@}, '\\1[FILTERED]@')
+        .gsub(%r{(https?://[^\s?#]+)[?#][^\s]*}, '\\1')
+        .slice(0, MAX_STRING)
+    end
+  end
+end

data/lib/rails_mind/transport.rb

@@ -0,0 +1,49 @@
+require "net/http"
+require "json"
+
+module RailsMind
+  class Transport
+    Result = Struct.new(:success, :retryable, :retry_after, keyword_init: true)
+    TRANSIENT_ERRORS = [ Timeout::Error, IOError, EOFError, SocketError, Errno::ECONNRESET,
+      Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, OpenSSL::SSL::SSLError ].freeze
+
+    def initialize(config, http_factory: ->(uri) { Net::HTTP.new(uri.host, uri.port, nil) })
+      @config = config
+      @http_factory = http_factory
+      @uri = URI(config.endpoint)
+      @uri.path = "#{@uri.path.sub(%r{/$}, '')}/api/v1/events" unless @uri.path.end_with?("/api/v1/events")
+    end
+
+    def send_batch(json)
+      Context.suppress do
+        request = Net::HTTP::Post.new(@uri)
+        request["Authorization"] = "Bearer #{@config.token}"
+        request["Content-Type"] = "application/json"
+        request["User-Agent"] = "rails_mind/#{VERSION}"
+        request.body = json
+        http = @http_factory.call(@uri)
+        http.use_ssl = @uri.scheme == "https"
+        http.open_timeout = @config.open_timeout
+        http.read_timeout = @config.read_timeout
+        http.write_timeout = @config.read_timeout
+        http.max_retries = 0
+        response = http.start { |connection| connection.request(request) }
+        code = response.code.to_i
+        Result.new(success: (200..299).cover?(code), retryable: code == 429 || code >= 500,
+          retry_after: retry_after(response["Retry-After"]))
+      end
+    rescue *TRANSIENT_ERRORS
+      Result.new(success: false, retryable: true)
+    end
+
+    private
+
+    def retry_after(value)
+      return nil unless value
+      seconds = value.match?(/\A\d+\z/) ? value.to_i : Time.httpdate(value) - Time.now
+      [ [ seconds, 0 ].max, 30 ].min
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/rails_mind/version.rb

@@ -0,0 +1,3 @@
+module RailsMind
+  VERSION = "0.1.0"
+end

data/lib/rails_mind.rb

@@ -0,0 +1,34 @@
+require_relative "rails_mind/version"
+require_relative "rails_mind/configuration"
+require_relative "rails_mind/context"
+require_relative "rails_mind/redactor"
+require_relative "rails_mind/transport"
+require_relative "rails_mind/collector"
+require_relative "rails_mind/client"
+
+module RailsMind
+  class << self
+    attr_writer :client
+
+    def configuration = @configuration ||= Configuration.new
+    def client = @client ||= Client.new(configuration)
+
+    def configure
+      yield configuration
+      @client&.collector&.shutdown
+      @client = Client.new(configuration)
+    end
+
+    def track(name, properties = {}, id: nil, occurred_at: nil, **additional_properties)
+      client.emit(:event, name, properties: properties.merge(additional_properties), id: id, occurred_at: occurred_at)
+    end
+    def capture_exception(error, **options) = client.capture_exception(error, **options)
+    def with_context(**context, &block) = Context.with(context, &block)
+    def identify(**identity) = Context.identify(**identity)
+    def flush(timeout: configuration.shutdown_timeout) = client.collector&.flush(timeout: timeout)
+    def shutdown = @client&.collector&.shutdown
+    def stats = client.collector&.stats || { enabled: false }
+  end
+end
+
+require_relative "rails_mind/railtie" if defined?(Rails::Railtie)

data/lib/tasks/rails_mind.rake

@@ -0,0 +1,15 @@
+namespace :rails_mind do
+  desc "Send one installation check; confirm its processing in RailsMind Setup"
+  task verify: :environment do
+    require "rails_mind/installation_check"
+    result = RailsMind::InstallationCheck.new.run
+    puts JSON.pretty_generate(result)
+    exit 1 unless result[:success]
+  end
+
+  desc "Inspect dependencies and report the non-destructive integration plan"
+  task doctor: :environment do
+    require "rails_mind/diagnostic"
+    puts JSON.pretty_generate(RailsMind::Diagnostic.new(root: Rails.root).report.merge(collector: RailsMind.stats))
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: rails_mind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- RailsMind
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: The RailsMind client for Rails request, error, job, and business-event
+  telemetry, with optional Ahoy, Flipper, OpenTelemetry, and browser integrations.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- docs/compatibility.md
+- docs/sdk.md
+- javascript/rails_mind.js
+- lib/generators/rails_mind/install/install_generator.rb
+- lib/generators/rails_mind/install/templates/initializer.rb.tt
+- lib/rails_mind.rb
+- lib/rails_mind/client.rb
+- lib/rails_mind/collector.rb
+- lib/rails_mind/configuration.rb
+- lib/rails_mind/context.rb
+- lib/rails_mind/diagnostic.rb
+- lib/rails_mind/installation_check.rb
+- lib/rails_mind/integrations/ahoy.rb
+- lib/rails_mind/integrations/open_telemetry.rb
+- lib/rails_mind/integrations/rails.rb
+- lib/rails_mind/railtie.rb
+- lib/rails_mind/redactor.rb
+- lib/rails_mind/transport.rb
+- lib/rails_mind/version.rb
+- lib/tasks/rails_mind.rake
+homepage: https://github.com/cmartyn/rails_mind
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/cmartyn/rails_mind
+  documentation_uri: https://github.com/cmartyn/rails_mind/blob/main/docs/sdk.md
+  bug_tracker_uri: https://github.com/cmartyn/rails_mind/issues
+  changelog_uri: https://github.com/cmartyn/rails_mind/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Bounded Rails telemetry for RailsMind
+test_files: []