nurse_andrea 0.1.7 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fff23d11632cc6f39d5b9348a63a7bf7d8b22b26bdce48272c3e11275e466e35
-  data.tar.gz: dd99bed6832c23297a66f430a8d1dfb61cec7038913eed1ecb0667e005f14317
+  metadata.gz: ae308e57dd4f7a8bf6182f34e49a8223cc695448e9a0ef0146b37396e6deea19
+  data.tar.gz: 7323b870d40f057ac56130b11061ca84bb9d9db9f97f61697c1234d392df296b
 SHA512:
-  metadata.gz: a1942f85a10fe0e6abb371d758a26ded283c3b07af1785e5f8f9cef526badb2fb9cea82080ebf54b8a54277aac46bc59bdc8f5134013341aa538e01ef03a4140
-  data.tar.gz: 6276bb6c051cd9cabf6d6e85b03fafdc7257397ad576d4e8bb614ecb7364542fc62b6c7883ed5163a274a6d3ce315ea6f30769d16e0b799444e6e63300b44717
+  metadata.gz: 4848f27cff94597a94a21b6fe366da00c547831aad652717e59a41255d25005142bf6a1b8fb9181f37a7358ee88e08e4e597b5e1c83cdff8da052ea716c2b583
+  data.tar.gz: f01a8a679ddcd4be389125c43ca2cfeca6703acc5dcf29f53a392896406f6384e87aaba578d24fd86d4a8e474400779c47dd2e02b02e3b751131458a604c7ee2

data/lib/nurse_andrea/DATA_PRIVACY_POLICY.rb

@@ -0,0 +1,29 @@
+# ============================================================
+# NURSEANDREA DATA PRIVACY POLICY — INVIOLABLE
+# ============================================================
+#
+# This SDK reads environment variables (DATABASE_URL, REDIS_URL,
+# etc.) and framework instrumentation hooks to detect secondary
+# components. It NEVER transmits:
+#
+#   - Raw environment variable values
+#   - Connection strings or URLs
+#   - Credentials (usernames, passwords, API tokens)
+#   - Hostnames, IP addresses, or ports
+#   - Database names or paths
+#
+# Only derived metadata is transmitted to NurseAndrea servers:
+#
+#   - type          (e.g. "database", "cache", "queue")
+#   - tech          (e.g. "postgresql", "redis")
+#   - provider      (e.g. "railway", "neon", "upstash")
+#   - source        (e.g. "env_detection", "hook_subscription")
+#   - variable_name (e.g. "DATABASE_URL" — the name, not the value)
+#
+# The Sanitizer module enforces this policy. All discovery records
+# pass through the Sanitizer before transmission. Any field not on
+# the allowlist is stripped.
+#
+# This policy is a commitment to our customers. Violating it is
+# a shipping-blocking defect.
+# ============================================================

data/lib/nurse_andrea/component_telemetry.rb

@@ -0,0 +1,113 @@
+# PRIVACY: This file aggregates framework hook data in-process.
+# Only counts and durations are shipped — no query text, no keys,
+# no raw data. See DATA_PRIVACY_POLICY.rb for the full policy.
+
+require "set"
+
+module NurseAndrea
+  class ComponentTelemetry
+    attr_reader :db, :cache, :jobs
+
+    def initialize
+      reset!
+    end
+
+    def record_query(duration_ms:, table: nil)
+      @db[:query_count] += 1
+      @db[:total_duration_ms] += duration_ms
+      @db[:slow_query_count] += 1 if duration_ms > 100
+      @db[:tables_accessed].add(table) if table.present?
+    end
+
+    def record_transaction(outcome:)
+      @db[:transaction_count] += 1
+      @db[:rollback_count] += 1 if outcome.to_s == "rollback"
+    end
+
+    def record_cache_read(hit:)
+      @cache[:read_count] += 1
+      hit ? @cache[:hit_count] += 1 : @cache[:miss_count] += 1
+    end
+
+    def record_cache_write
+      @cache[:write_count] += 1
+    end
+
+    def record_cache_delete
+      @cache[:delete_count] += 1
+    end
+
+    def record_job_complete(duration_ms:, queue_name: nil)
+      @jobs[:complete_count] += 1
+      @jobs[:total_duration_ms] += duration_ms
+      @jobs[:queue_names].add(queue_name) if queue_name.present?
+    end
+
+    def record_job_enqueue(queue_name: nil)
+      @jobs[:enqueue_count] += 1
+      @jobs[:queue_names].add(queue_name) if queue_name.present?
+    end
+
+    def record_job_fail(queue_name: nil)
+      @jobs[:fail_count] += 1
+      @jobs[:queue_names].add(queue_name) if queue_name.present?
+    end
+
+    def snapshot_and_reset!
+      metrics = []
+
+      if @db[:query_count] > 0
+        metrics << {
+          type: "database", tech: @db[:tech],
+          interval_ms: NurseAndrea.config.hook_interval_ms,
+          query_count: @db[:query_count],
+          slow_query_count: @db[:slow_query_count],
+          total_duration_ms: @db[:total_duration_ms].round(2),
+          tables_accessed: @db[:tables_accessed].to_a,
+          transaction_count: @db[:transaction_count],
+          rollback_count: @db[:rollback_count],
+          error_count: 0
+        }
+      end
+
+      if @cache[:read_count] > 0 || @cache[:write_count] > 0
+        metrics << {
+          type: "cache", tech: @cache[:tech],
+          interval_ms: NurseAndrea.config.hook_interval_ms,
+          read_count: @cache[:read_count], write_count: @cache[:write_count],
+          hit_count: @cache[:hit_count], miss_count: @cache[:miss_count],
+          delete_count: @cache[:delete_count],
+          total_duration_ms: 0, error_count: 0
+        }
+      end
+
+      if @jobs[:enqueue_count] > 0 || @jobs[:complete_count] > 0
+        metrics << {
+          type: "queue", tech: @jobs[:tech],
+          interval_ms: NurseAndrea.config.hook_interval_ms,
+          enqueue_count: @jobs[:enqueue_count],
+          complete_count: @jobs[:complete_count],
+          fail_count: @jobs[:fail_count],
+          total_duration_ms: @jobs[:total_duration_ms].round(2),
+          queue_names: @jobs[:queue_names].to_a,
+          retry_count: 0, error_count: 0
+        }
+      end
+
+      reset!
+      metrics
+    end
+
+    private
+
+    def reset!
+      @db = { tech: "unknown", query_count: 0, slow_query_count: 0,
+              total_duration_ms: 0.0, tables_accessed: Set.new,
+              transaction_count: 0, rollback_count: 0 }
+      @cache = { tech: "unknown", read_count: 0, write_count: 0,
+                 hit_count: 0, miss_count: 0, delete_count: 0 }
+      @jobs = { tech: "unknown", enqueue_count: 0, complete_count: 0,
+                fail_count: 0, total_duration_ms: 0.0, queue_names: Set.new }
+    end
+  end
+end

data/lib/nurse_andrea/configuration.rb

@@ -3,7 +3,10 @@ module NurseAndrea
     attr_accessor :api_key, :host, :timeout, :log_level, :batch_size,
                   :flush_interval, :backfill_hours, :log_file_path,
                   :enabled, :debug, :service_name,
-                  :sdk_version, :sdk_language
+                  :sdk_version, :sdk_language,
+                  :hooks_enabled, :hooks_database, :hooks_cache,
+                  :hooks_jobs, :hooks_mailer, :hook_interval_ms,
+                  :platform_detection, :service_discovery, :auto_connect
 
     LOG_LEVELS   = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }.freeze
     DEFAULT_HOST = "https://nurseandrea.io"
@@ -16,11 +19,20 @@ module NurseAndrea
       @flush_interval = 10
       @backfill_hours = 24
       @log_file_path  = nil
-      @enabled        = true
-      @debug          = false
-      @service_name   = default_service_name
-      @sdk_version    = NurseAndrea::VERSION
-      @sdk_language   = "ruby"
+      @enabled            = true
+      @debug              = false
+      @service_name       = default_service_name
+      @sdk_version        = NurseAndrea::VERSION
+      @sdk_language       = "ruby"
+      @hooks_enabled      = true
+      @hooks_database     = true
+      @hooks_cache        = true
+      @hooks_jobs         = true
+      @hooks_mailer       = true
+      @hook_interval_ms   = 10_000
+      @platform_detection = true
+      @service_discovery  = true
+      @auto_connect       = false
     end
 
     alias_method :token,  :api_key
@@ -31,6 +43,7 @@ module NurseAndrea
     def metrics_url   = "#{normalised_host}/api/v1/metrics"
     def traces_url    = "#{normalised_host}/api/v1/traces"
     def handshake_url = "#{normalised_host}/api/v1/handshake"
+    def deploy_url    = "#{normalised_host}/api/v1/deploy"
 
     def enabled?
       @enabled

data/lib/nurse_andrea/deploy.rb

@@ -0,0 +1,35 @@
+module NurseAndrea
+  # Public: ship a deploy event to the NurseAndrea backend so the
+  # dashboard can render it as a vertical marker on time-series charts
+  # and as a chip in the recent-deploys strip.
+  #
+  # Fire-and-forget: any failure (no token, network error, non-2xx) is
+  # logged in debug mode and swallowed so the host application never
+  # crashes from a deploy notification.
+  module Deploy
+    DESCRIPTION_LIMIT = 500
+
+    def self.call(version:, deployer: nil, environment: "production", description: nil)
+      return false unless NurseAndrea.config.valid?
+      return false if version.to_s.strip.empty?
+
+      payload = {
+        version:     version.to_s,
+        deployer:    deployer,
+        environment: environment,
+        description: description.is_a?(String) ? description[0, DESCRIPTION_LIMIT] : description,
+        deployed_at: Time.now.utc.iso8601
+      }.compact
+
+      HttpClient.new.post(NurseAndrea.config.deploy_url, payload)
+    rescue => e
+      NurseAndrea.debug("[NurseAndrea] deploy() error: #{e.class}: #{e.message}")
+      false
+    end
+  end
+
+  # Convenience top-level: NurseAndrea.deploy(version: "1.4.2")
+  def self.deploy(**kwargs)
+    Deploy.call(**kwargs)
+  end
+end

data/lib/nurse_andrea/instrumentation_subscriber.rb

@@ -0,0 +1,177 @@
+# PRIVACY: This file subscribes to framework instrumentation hooks.
+# Query text is aggregated (table names extracted) but never shipped raw.
+# See DATA_PRIVACY_POLICY.rb for the full policy.
+
+require "set"
+
+module NurseAndrea
+  class InstrumentationSubscriber
+    SUBSCRIPTIONS = {
+      "sql.active_record"           => :on_sql,
+      "transaction.active_record"   => :on_transaction,
+      "cache_read.active_support"   => :on_cache_read,
+      "cache_write.active_support"  => :on_cache_write,
+      "cache_delete.active_support" => :on_cache_delete,
+      "perform.active_job"          => :on_job_perform,
+      "enqueue.active_job"          => :on_job_enqueue,
+      "deliver.action_mailer"       => :on_mailer
+    }.freeze
+
+    attr_reader :telemetry, :discovered_components
+
+    def initialize
+      @telemetry = ComponentTelemetry.new
+      @discovered_components = Set.new
+      @subscribed = false
+    end
+
+    def subscribe_all
+      return if @subscribed
+      return unless defined?(ActiveSupport::Notifications)
+
+      SUBSCRIPTIONS.each do |event_name, handler|
+        ActiveSupport::Notifications.monotonic_subscribe(event_name) do |event|
+          begin
+            send(handler, event)
+          rescue => e
+            NurseAndrea.debug("[InstrumentationSubscriber] #{handler} error: #{e.message}")
+          end
+        end
+      end
+
+      @subscribed = true
+    end
+
+    private
+
+    def on_sql(event)
+      return if event.payload[:name] == "SCHEMA"
+      return if event.payload[:name]&.start_with?("EXPLAIN")
+
+      conn    = event.payload[:connection]
+      adapter = conn&.adapter_name rescue nil
+
+      # Skip platform's own ClickHouse queries — not the customer's infrastructure
+      return if adapter&.downcase&.include?("clickhouse")
+
+      tech = adapter_to_tech(adapter)
+      register_discovery("database", tech, connection: conn) if tech
+
+      table = extract_table(event.payload[:sql])
+      @telemetry.record_query(duration_ms: event.duration, table: table)
+    end
+
+    def on_transaction(event)
+      outcome = event.payload[:outcome]
+      @telemetry.record_transaction(outcome: outcome)
+    end
+
+    def on_cache_read(event)
+      tech = store_to_tech(event.payload[:store])
+
+      # Only register external cache stores as components
+      register_discovery("cache", tech) if tech
+
+      # Still record telemetry for all cache reads
+      @telemetry.record_cache_read(hit: event.payload[:hit])
+    end
+
+    def on_cache_write(_event)
+      @telemetry.record_cache_write
+    end
+
+    def on_cache_delete(_event)
+      @telemetry.record_cache_delete
+    end
+
+    def on_job_perform(event)
+      adapter = detect_queue_adapter
+      register_discovery("queue", adapter)
+      @telemetry.record_job_complete(
+        duration_ms: event.duration,
+        queue_name: event.payload[:job]&.queue_name
+      )
+    end
+
+    def on_job_enqueue(event)
+      @telemetry.record_job_enqueue(queue_name: event.payload[:job]&.queue_name)
+    end
+
+    def on_mailer(_event)
+      register_discovery("external", "email")
+    end
+
+    def register_discovery(type, tech, connection: nil)
+      return if tech.nil? || tech.empty? || tech == "unknown"
+      return if self_referential?(connection)
+
+      key = "#{type}:#{tech}"
+      return if @discovered_components.include?(key)
+
+      @discovered_components.add(key)
+      NurseAndrea.component_discoveries << Sanitizer.sanitize_discovery(
+        type: type, tech: tech, provider: "unknown",
+        source: "hook_subscription", variable_name: nil
+      )
+    end
+
+    # True when the SDK is running inside NurseAndrea itself, OR when
+    # the SQL event's connection points at NurseAndrea's own infra.
+    # Either way the discovery would be a self-reference, not a
+    # customer component. Process-level + connection-level checks are
+    # both consulted; the same module powers the env-scanner filter.
+    def self_referential?(connection)
+      return true if NurseAndrea::SelfFilter.platform_self?
+      return false unless connection
+
+      db_name = connection.current_database.to_s rescue ""
+      host    = connection.pool&.db_config&.host.to_s rescue ""
+      NurseAndrea::SelfFilter.host_matches?(db_name, host)
+    end
+
+    def adapter_to_tech(adapter_name)
+      case adapter_name&.downcase
+      when "postgresql", "postgis" then "postgresql"
+      when "mysql2", "trilogy"     then "mysql"
+      when "sqlite3"               then "sqlite"
+      when "clickhouse"            then nil
+      else adapter_name&.downcase.presence
+      end
+    end
+
+    def store_to_tech(store_class)
+      case store_class.to_s
+      when /Redis/i    then "redis"
+      when /Memcache/i then "memcached"
+      when /Memory/i   then nil  # In-process, not infrastructure
+      when /File/i     then nil  # Local filesystem, not infrastructure
+      when /Null/i     then nil  # No-op store
+      else nil
+      end
+    end
+
+    def detect_queue_adapter
+      return "unknown" unless defined?(ActiveJob::Base)
+      adapter = ActiveJob::Base.queue_adapter.class.name rescue nil
+      case adapter
+      when /Sidekiq/i    then "sidekiq"
+      when /SolidQueue/i then "solid_queue"
+      when /Resque/i     then "resque"
+      when /DelayedJob/i then "delayed_job"
+      when /GoodJob/i    then "good_job"
+      else "unknown"
+      end
+    end
+
+    def extract_table(sql)
+      return nil if sql.nil? || sql.empty?
+      if sql =~ /\bFROM\s+["`]?(\w+)["`]?/i
+        $1
+      elsif sql =~ /\bINTO\s+["`]?(\w+)["`]?/i
+        $1
+      elsif sql =~ /\bUPDATE\s+["`]?(\w+)["`]?/i
+        $1
+      end
+    end
+  end
+end

data/lib/nurse_andrea/job_instrumentation.rb

@@ -0,0 +1,52 @@
+require "active_support/concern"
+
+module NurseAndrea
+  module JobInstrumentation
+    extend ActiveSupport::Concern
+
+    included do
+      around_perform :nurseandrea_instrument_job
+    end
+
+    private
+
+    def nurseandrea_instrument_job
+      return yield unless NurseAndrea.config.enabled?
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      status = "completed"
+      error_class = nil
+      error_message = nil
+
+      begin
+        yield
+      rescue => e
+        status = "failed"
+        error_class = e.class.name
+        error_message = e.message.to_s[0, 500]
+        raise
+      ensure
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+
+        NurseAndrea::MetricsShipper.instance.enqueue(
+          name:      "job.perform",
+          value:     duration_ms,
+          unit:      "ms",
+          timestamp: Time.now.utc.iso8601(3),
+          tags:      {
+            job_class:     self.class.name,
+            queue_name:    queue_name,
+            status:        status,
+            error_class:   error_class,
+            attempts:      executions,
+            priority:      priority
+          }.compact
+        )
+
+        if NurseAndrea.config.debug
+          warn "[NurseAndrea::JobInstrumentation] #{self.class.name} #{status} in #{duration_ms}ms"
+        end
+      end
+    end
+  end
+end

data/lib/nurse_andrea/managed_service_scanner.rb

@@ -0,0 +1,51 @@
+# PRIVACY: This file reads environment variable values to derive
+# component metadata. Raw values never leave this process. Only
+# derived metadata (type, tech, provider) is transmitted.
+# See DATA_PRIVACY_POLICY.rb for the full policy.
+
+module NurseAndrea
+  module ManagedServiceScanner
+    SCAN_MAP = {
+      "DATABASE_URL"      => "database",
+      "DATABASE_PRIVATE_URL" => "database",
+      "REDIS_URL"         => "cache",
+      "REDIS_PRIVATE_URL" => "cache",
+      "RABBITMQ_URL"      => "queue",
+      "CLOUDAMQP_URL"     => "queue",
+      "MONGODB_URI"       => "database",
+      "MONGO_URL"         => "database",
+      "ELASTICSEARCH_URL" => "search",
+      "KAFKA_BROKERS"     => "queue"
+    }.freeze
+
+    def self.scan
+      # Skip env-based discovery entirely when the SDK is loaded inside
+      # NurseAndrea itself — every URL we'd find belongs to the platform's
+      # own infrastructure, not a customer component.
+      return [] if NurseAndrea::SelfFilter.platform_self?
+
+      discoveries = []
+
+      SCAN_MAP.each do |var_name, component_type|
+        url = ENV[var_name]
+        next if url.nil? || url.strip.empty?
+        next if NurseAndrea::SelfFilter.host_matches?(url)
+
+        tech     = Sanitizer.extract_tech(url)
+        provider = Sanitizer.extract_provider(url)
+
+        raw = {
+          type: component_type,
+          tech: tech,
+          provider: provider,
+          source: "env_detection",
+          variable_name: var_name
+        }
+
+        discoveries << Sanitizer.sanitize_discovery(raw)
+      end
+
+      discoveries.uniq { |d| [ d[:type], d[:tech], d[:provider] ] }
+    end
+  end
+end

data/lib/nurse_andrea/memory_sampler.rb

@@ -0,0 +1,55 @@
+module NurseAndrea
+  class MemorySampler
+    INTERVAL_SECONDS = 30
+
+    def self.start
+      return @thread if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep INTERVAL_SECONDS
+          sample_and_enqueue
+        rescue => e
+          NurseAndrea.debug("[NurseAndrea] MemorySampler error: #{e.message}")
+        end
+      end
+      @thread.abort_on_exception = false
+      @thread.name = "NurseAndrea::MemorySampler"
+      @thread
+    end
+
+    def self.stop
+      @thread&.kill
+      @thread = nil
+    end
+
+    # Returns RSS in bytes. Works on Linux (/proc) and macOS (ps).
+    def self.rss_bytes
+      if File.exist?("/proc/self/status")
+        line = File.readlines("/proc/self/status").find { |l| l.start_with?("VmRSS:") }
+        return nil unless line
+        kb = line.split[1].to_i
+        kb * 1024
+      else
+        kb = `ps -o rss= -p #{Process.pid}`.strip.to_i
+        return nil if kb == 0
+        kb * 1024
+      end
+    rescue
+      nil
+    end
+
+    def self.sample_and_enqueue
+      bytes = rss_bytes
+      return unless bytes && bytes > 0
+
+      MetricsShipper.instance.enqueue(
+        name:      "process.memory.rss",
+        value:     bytes,
+        unit:      "bytes",
+        tags:      { service: NurseAndrea.config.service_name },
+        timestamp: Time.now.utc.iso8601(3)
+      )
+    end
+  end
+end

data/lib/nurse_andrea/metrics_shipper.rb

@@ -62,9 +62,10 @@ module NurseAndrea
     end
 
     def ship(metrics)
-      HttpClient.new.post(NurseAndrea.config.metrics_url, {
+      payload = {
         sdk_version:  NurseAndrea.config.sdk_version,
         sdk_language: NurseAndrea.config.sdk_language,
+        platform:     NurseAndrea.platform_context,
         metrics: metrics.map { |m|
           {
             name:        m[:name],
@@ -74,7 +75,21 @@ module NurseAndrea
             occurred_at: m[:timestamp]
           }
         }
-      })
+      }
+
+      # Include component telemetry if available
+      component_metrics = NurseAndrea.instrumentation_subscriber
+                                      .telemetry
+                                      .snapshot_and_reset!
+      payload[:component_metrics] = component_metrics if component_metrics.any?
+
+      # Include component discoveries (flush once)
+      if NurseAndrea.component_discoveries.any?
+        payload[:component_discoveries] = NurseAndrea.component_discoveries.dup
+        NurseAndrea.component_discoveries.clear
+      end
+
+      HttpClient.new.post(NurseAndrea.config.metrics_url, payload)
     end
   end
 end

data/lib/nurse_andrea/platform_detector.rb

@@ -0,0 +1,40 @@
+# PRIVACY: This file reads environment variable NAMES to detect
+# the hosting platform. Only the platform name is transmitted.
+# See DATA_PRIVACY_POLICY.rb for the full policy.
+
+module NurseAndrea
+  module PlatformDetector
+    PLATFORMS = {
+      railway:      -> { ENV.key?("RAILWAY_ENVIRONMENT") },
+      render:       -> { ENV.key?("RENDER") },
+      fly:          -> { ENV.key?("FLY_APP_NAME") },
+      heroku:       -> { ENV.key?("DYNO") },
+      digitalocean: -> { ENV.key?("DIGITALOCEAN_APP_PLATFORM_COMPONENT_NAME") },
+      vercel:       -> { ENV.key?("VERCEL") }
+    }.freeze
+
+    def self.detect
+      PLATFORMS.each { |name, check| return name.to_s if check.call }
+      "unknown"
+    end
+
+    def self.context
+      platform = detect
+      ctx = { platform: platform }
+
+      case platform
+      when "railway"
+        ctx[:region] = ENV["RAILWAY_REGION"] if ENV.key?("RAILWAY_REGION")
+        ctx[:environment] = ENV["RAILWAY_ENVIRONMENT"] if ENV.key?("RAILWAY_ENVIRONMENT")
+      when "render"
+        ctx[:region] = ENV["RENDER_REGION"] if ENV.key?("RENDER_REGION")
+      when "fly"
+        ctx[:region] = ENV["FLY_REGION"] if ENV.key?("FLY_REGION")
+      when "heroku"
+        ctx[:dyno_type] = ENV["DYNO"]&.gsub(/\.\d+$/, "") if ENV.key?("DYNO")
+      end
+
+      ctx
+    end
+  end
+end

data/lib/nurse_andrea/query_subscriber.rb

@@ -0,0 +1,49 @@
+module NurseAndrea
+  class QuerySubscriber
+    SKIP_PATTERN = /\A(SHOW|SET|PRAGMA|SELECT.*schema_migrations|BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE|SELECT version)/i
+    SKIP_CONNECTIONS = %w[ClickhouseActiverecord Clickhouse].freeze
+    SLOW_THRESHOLD_MS = 100
+
+    def self.subscribe!
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |name, start, finish, id, payload|
+        next if payload[:name] == "SCHEMA"
+
+        # Only instrument PostgreSQL queries — skip ClickHouse
+        conn = payload[:connection]
+        conn_name = conn.is_a?(Class) ? conn.name.to_s : conn.class.name.to_s
+        next if SKIP_CONNECTIONS.any? { |c| conn_name.include?(c) }
+        # Also skip by adapter name if available
+        next if payload[:connection_id].to_s.include?("clickhouse")
+
+        # Skip queries targeting ClickHouse tables
+        sql_check = payload[:sql].to_s
+        next if sql_check.match?(/\b(metric_points|log_entries|job_metrics|spans)\b/i)
+
+        sql = payload[:sql].to_s.strip
+        next if sql.empty?
+        next if sql.match?(SKIP_PATTERN)
+
+        duration_ms = ((finish - start) * 1000).round(2)
+        timestamp   = finish.utc.iso8601(3)
+
+        # Always ship slow queries
+        if duration_ms >= SLOW_THRESHOLD_MS
+          LogShipper.instance.enqueue(
+            level:     "warn",
+            message:   "SLOW QUERY took #{duration_ms.round}ms: #{sql.first(2000)}",
+            timestamp: timestamp
+          )
+        end
+
+        # Sample 10% of all queries for frequency tracking
+        if rand < 0.1
+          LogShipper.instance.enqueue(
+            level:     "debug",
+            message:   "#{duration_ms.round}ms: #{sql.first(2000)}",
+            timestamp: timestamp
+          )
+        end
+      end
+    end
+  end
+end

data/lib/nurse_andrea/queue_depth_reporter.rb

@@ -0,0 +1,63 @@
+module NurseAndrea
+  class QueueDepthReporter
+    # Auto-detects Solid Queue or Sidekiq and reports queue depths.
+    # Returns an array of metric hashes ready for MetricsShipper.
+
+    def self.report!
+      new.report!
+    end
+
+    def report!
+      metrics = []
+      now = Time.now.utc.iso8601(3)
+
+      if solid_queue?
+        metrics.concat(solid_queue_depths(now))
+      elsif sidekiq?
+        metrics.concat(sidekiq_depths(now))
+      end
+
+      metrics.each { |m| NurseAndrea::MetricsShipper.instance.enqueue(m) }
+      metrics
+    end
+
+    private
+
+    def solid_queue?
+      defined?(SolidQueue::Job)
+    end
+
+    def sidekiq?
+      defined?(Sidekiq::Queue)
+    end
+
+    def solid_queue_depths(now)
+      queues = SolidQueue::Job
+        .where(finished_at: nil)
+        .group(:queue_name)
+        .count
+
+      queues.map do |queue_name, depth|
+        {
+          name:      "queue.depth",
+          value:     depth,
+          unit:      "count",
+          timestamp: now,
+          tags:      { queue_name: queue_name, backend: "solid_queue" }
+        }
+      end
+    end
+
+    def sidekiq_depths(now)
+      Sidekiq::Queue.all.map do |queue|
+        {
+          name:      "queue.depth",
+          value:     queue.size,
+          unit:      "count",
+          timestamp: now,
+          tags:      { queue_name: queue.name, backend: "sidekiq" }
+        }
+      end
+    end
+  end
+end

data/lib/nurse_andrea/railtie.rb

@@ -9,6 +9,7 @@ module NurseAndrea
         Rails.logger = NurseAndrea::LogInterceptor.new(Rails.logger)
         NurseAndrea::LogShipper.instance.start!
         NurseAndrea::MetricsShipper.instance.start!
+        NurseAndrea::MemorySampler.start
         Rails.logger.info("[NurseAndrea] Logger interceptor installed " \
                           "(host: #{NurseAndrea.config.host}, " \
                           "service: #{NurseAndrea.config.service_name || 'auto'})")
@@ -29,12 +30,37 @@ module NurseAndrea
       end
     end
 
+    # Component discovery + instrumentation hooks
+    initializer "nurse_andrea.instrumentation", after: :load_config_initializers do
+      next unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
+
+      # Platform detection
+      if NurseAndrea.config.platform_detection
+        ctx = NurseAndrea.platform_context
+        NurseAndrea.debug("[NurseAndrea] Platform: #{ctx[:platform]}")
+      end
+
+      # Managed service discovery (DATABASE_URL, REDIS_URL, etc.)
+      if NurseAndrea.config.service_discovery
+        discoveries = NurseAndrea::ManagedServiceScanner.scan
+        NurseAndrea.component_discoveries.concat(discoveries)
+        NurseAndrea.debug("[NurseAndrea] Discovered #{discoveries.size} managed services")
+      end
+
+      # Hook subscriptions (sql.active_record, cache_*, perform.active_job, etc.)
+      if NurseAndrea.config.hooks_enabled
+        NurseAndrea.instrumentation_subscriber.subscribe_all
+      end
+    end
+
     config.after_initialize do
       next unless NurseAndrea.config.enabled? && NurseAndrea.config.valid?
       NurseAndrea::Backfill.run_async!
+      NurseAndrea::QuerySubscriber.subscribe!
     end
 
     at_exit do
+      NurseAndrea::MemorySampler.stop rescue nil
       NurseAndrea::LogShipper.instance.flush! rescue nil
       NurseAndrea::MetricsShipper.instance.flush! rescue nil
     end

data/lib/nurse_andrea/sanitizer.rb

@@ -0,0 +1,45 @@
+# PRIVACY: This file enforces the data privacy policy. Only allowlisted
+# fields pass through. See DATA_PRIVACY_POLICY.rb for the full policy.
+
+require "uri"
+
+module NurseAndrea
+  module Sanitizer
+    DISCOVERY_ALLOWLIST = %i[type tech provider source variable_name].freeze
+
+    def self.sanitize_discovery(raw)
+      raw.slice(*DISCOVERY_ALLOWLIST)
+    end
+
+    def self.extract_tech(url)
+      scheme = URI.parse(url).scheme rescue nil
+      case scheme
+      when "postgres", "postgresql" then "postgresql"
+      when "mysql", "mysql2"        then "mysql"
+      when "redis", "rediss"        then "redis"
+      when "amqp", "amqps"          then "rabbitmq"
+      when "mongodb", "mongodb+srv" then "mongodb"
+      else "unknown"
+      end
+    end
+
+    def self.extract_provider(url)
+      host = URI.parse(url).host rescue nil
+      return "unknown" unless host
+
+      case host
+      when /\.railway\.internal$/       then "railway"
+      when /\.render\.com$/             then "render"
+      when /\.fly\.dev$/                then "fly"
+      when /\.neon\.tech$/              then "neon"
+      when /\.supabase\.co$/            then "supabase"
+      when /\.upstash\.io$/             then "upstash"
+      when /\.mongodb\.net$/            then "mongodb_atlas"
+      when /\.herokuapp\.com$/          then "heroku"
+      when /\.elephantsql\.com$/        then "elephantsql"
+      when /\.aws\.clickhouse\.cloud$/  then "clickhouse_cloud"
+      else "self_hosted"
+      end
+    end
+  end
+end

data/lib/nurse_andrea/self_filter.rb

@@ -0,0 +1,39 @@
+# Suppresses discovery emission when the SDK is loaded inside
+# NurseAndrea itself. Both the InstrumentationSubscriber (hook-based)
+# and the ManagedServiceScanner (env-based) must consult this filter
+# before adding to NurseAndrea.component_discoveries — otherwise the
+# platform's own infrastructure shows up as proposed components on
+# every workspace dashboard.
+
+module NurseAndrea
+  module SelfFilter
+    SELF_INDICATORS = %w[nurseandrea nurse-andrea nurse_andrea].freeze
+
+    class << self
+      def platform_self?
+        return @platform_self if defined?(@platform_self)
+        @platform_self = compute_platform_self
+      end
+
+      def reset!
+        remove_instance_variable(:@platform_self) if defined?(@platform_self)
+      end
+
+      def host_matches?(*candidates)
+        candidates.compact.map(&:to_s).map(&:downcase).any? do |s|
+          SELF_INDICATORS.any? { |i| s.include?(i) }
+        end
+      end
+
+      private
+
+      def compute_platform_self
+        return false unless defined?(Rails) && Rails.application
+        app_name = Rails.application.class.module_parent_name.to_s.downcase
+        SELF_INDICATORS.any? { |i| app_name.include?(i) }
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/nurse_andrea/version.rb

@@ -1,3 +1,3 @@
 module NurseAndrea
-  VERSION = "0.1.7"
+  VERSION = "0.2.3"
 end

data/lib/nurse_andrea.rb

@@ -6,6 +6,17 @@ require "nurse_andrea/log_shipper"
 require "nurse_andrea/metrics_middleware"
 require "nurse_andrea/metrics_shipper"
 require "nurse_andrea/backfill"
+require "nurse_andrea/job_instrumentation"
+require "nurse_andrea/queue_depth_reporter"
+require "nurse_andrea/query_subscriber"
+require "nurse_andrea/sanitizer"
+require "nurse_andrea/platform_detector"
+require "nurse_andrea/managed_service_scanner"
+require "nurse_andrea/component_telemetry"
+require "nurse_andrea/instrumentation_subscriber"
+require "nurse_andrea/memory_sampler"
+require "nurse_andrea/deploy"
+require "nurse_andrea/self_filter"
 
 require "nurse_andrea/railtie" if defined?(Rails::Railtie)
 require "nurse_andrea/engine"  if defined?(Rails::Engine)
@@ -24,6 +35,26 @@ module NurseAndrea
 
     def reset_config!
       @config = nil
+      @instrumentation_subscriber = nil
+      @component_discoveries = nil
+      @platform_context = nil
+    end
+
+    def instrumentation_subscriber
+      @instrumentation_subscriber ||= InstrumentationSubscriber.new
+    end
+
+    def component_discoveries
+      @component_discoveries ||= []
+    end
+
+    def platform_context
+      @platform_context ||= PlatformDetector.context
+    end
+
+    def debug(message)
+      return unless config.debug
+      $stderr.puts(message)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nurse_andrea
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.3
 platform: ruby
 authors:
 - Ago AI LLC
@@ -24,15 +24,27 @@ files:
 - lib/generators/nurse_andrea/install/install_generator.rb
 - lib/generators/nurse_andrea/install/templates/nurse_andrea.rb.tt
 - lib/nurse_andrea.rb
+- lib/nurse_andrea/DATA_PRIVACY_POLICY.rb
 - lib/nurse_andrea/backfill.rb
+- lib/nurse_andrea/component_telemetry.rb
 - lib/nurse_andrea/configuration.rb
+- lib/nurse_andrea/deploy.rb
 - lib/nurse_andrea/engine.rb
 - lib/nurse_andrea/http_client.rb
+- lib/nurse_andrea/instrumentation_subscriber.rb
+- lib/nurse_andrea/job_instrumentation.rb
 - lib/nurse_andrea/log_interceptor.rb
 - lib/nurse_andrea/log_shipper.rb
+- lib/nurse_andrea/managed_service_scanner.rb
+- lib/nurse_andrea/memory_sampler.rb
 - lib/nurse_andrea/metrics_middleware.rb
 - lib/nurse_andrea/metrics_shipper.rb
+- lib/nurse_andrea/platform_detector.rb
+- lib/nurse_andrea/query_subscriber.rb
+- lib/nurse_andrea/queue_depth_reporter.rb
 - lib/nurse_andrea/railtie.rb
+- lib/nurse_andrea/sanitizer.rb
+- lib/nurse_andrea/self_filter.rb
 - lib/nurse_andrea/version.rb
 - nurse_andrea.gemspec
 homepage: https://nurseandrea.io