anomonitor 0.6.1

data/lib/anomonitor/metric_point.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Anomonitor
+  MetricPoint = Struct.new(:source, :metric, :value, :tags, :sampled_at, keyword_init: true) do
+    def initialize(source:, metric:, value:, tags: {}, sampled_at: Time.current)
+      super(
+        source: source.to_s,
+        metric: metric.to_s,
+        value: value.to_f,
+        tags: tags || {},
+        sampled_at: sampled_at
+      )
+    end
+
+    def sticky?
+      source == "schema_drift"
+    end
+
+    def cooldown_key
+      tenant = tags[:tenant] || tags["tenant"]
+      queue = tags[:queue] || tags["queue"]
+      parts = [source, metric, tenant, queue]
+      if sticky?
+        digest = sticky_items_digest
+        parts << digest if digest
+      end
+      parts.compact.join(":")
+    end
+
+    def sticky_items_digest
+      digest = tags[:items_digest] || tags["items_digest"]
+      return digest.to_s if digest && !digest.to_s.empty?
+
+      items = tags[:items] || tags["items"]
+      return nil if items.nil? || items.to_s.empty?
+
+      Digest::SHA256.hexdigest(items.to_s)[0, 16]
+    end
+  end
+end

data/lib/anomonitor/metrics_export.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module MetricsExport
+    module_function
+
+    def json_payload
+      latest = MetricSample.latest_by_source_metric
+      open_count = Anomaly.open.count
+      {
+        gem: "anomonitor",
+        version: Anomonitor::VERSION,
+        sampled_at: Time.current.iso8601,
+        open_anomalies: open_count,
+        metrics: latest.map do |s|
+          {
+            source: s.source,
+            metric: s.metric,
+            value: s.value,
+            tags: s.tags,
+            sampled_at: s.sampled_at&.iso8601
+          }
+        end
+      }
+    end
+
+    def prometheus_text
+      lines = []
+      lines << "# HELP anomonitor_open_anomalies Number of unresolved anomalies"
+      lines << "# TYPE anomonitor_open_anomalies gauge"
+      lines << "anomonitor_open_anomalies #{Anomaly.open.count}"
+
+      lines << "# HELP anomonitor_metric Latest metric sample value"
+      lines << "# TYPE anomonitor_metric gauge"
+      MetricSample.latest_by_source_metric.each do |s|
+        labels = { source: s.source, metric: s.metric }
+        tags = s.tags.is_a?(Hash) ? s.tags : {}
+        %w[tenant queue table].each do |key|
+          val = tags[key] || tags[key.to_sym]
+          labels[key] = val if val && !val.to_s.empty?
+        end
+        lines << "anomonitor_metric{#{prometheus_labels(labels)}} #{s.value.to_f}"
+      end
+      "#{lines.join("\n")}\n"
+    end
+
+    def prometheus_labels(hash)
+      hash.map { |k, v| "#{k}=\"#{escape_label(v)}\"" }.join(",")
+    end
+
+    def escape_label(value)
+      value.to_s.gsub("\\", "\\\\").gsub("\n", "\\n").gsub('"', '\\"')
+    end
+  end
+end

data/lib/anomonitor/notifiers/callable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Notifiers
+    class Callable
+      def initialize(callable)
+        @callable = callable
+      end
+
+      def deliver(anomaly, event: DETECTED)
+        result =
+          if accepts_event_kw?
+            @callable.call(anomaly, event: event.to_s)
+          else
+            @callable.call(anomaly)
+          end
+
+        normalize_result(result)
+      rescue StandardError => e
+        Anomonitor.logger.warn("[Anomonitor] Custom notifier error: #{e.message}")
+        false
+      end
+
+      private
+
+      def accepts_event_kw?
+        params = @callable.parameters
+        params.any? { |type, name| name == :event && %i[key keyreq keyrest].include?(type) } ||
+          params.any? { |type, _| type == :keyrest }
+      rescue StandardError
+        true
+      end
+
+      def normalize_result(result)
+        case result
+        when true, false then result
+        when Hash then result[:accepted] == true || result["accepted"] == true
+        else
+          !result.nil?
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/notifiers/composite.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Notifiers
+    class Composite
+      def initialize(notifiers)
+        @notifiers = Array(notifiers)
+      end
+
+      def deliver(anomaly, event: DETECTED)
+        results = @notifiers.map do |notifier|
+          notifier.deliver(anomaly, event: event)
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Notifier #{notifier.class} error: #{e.message}")
+          false
+        end
+        results.any?
+      end
+
+      def deliver_digest(payload)
+        results = @notifiers.map do |notifier|
+          next false unless notifier.respond_to?(:deliver_digest)
+
+          notifier.deliver_digest(payload)
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Digest notifier #{notifier.class} error: #{e.message}")
+          false
+        end
+        results.any?
+      end
+    end
+  end
+end

data/lib/anomonitor/notifiers/rate_limited.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Notifiers
+    class RateLimited
+      def initialize(notifier, limit_per_minute:)
+        @notifier = notifier
+        @limit = limit_per_minute.to_i
+        @timestamps = []
+        @mutex = Mutex.new
+      end
+
+      def deliver(anomaly, event: DETECTED)
+        return false unless allow?
+
+        @notifier.deliver(anomaly, event: event)
+      end
+
+      def deliver_digest(payload)
+        return false unless allow?
+        return @notifier.deliver_digest(payload) if @notifier.respond_to?(:deliver_digest)
+
+        false
+      end
+
+      private
+
+      def allow?
+        return true if @limit <= 0
+
+        @mutex.synchronize do
+          cutoff = Time.current - 60
+          @timestamps.reject! { |t| t < cutoff }
+          if @timestamps.size >= @limit
+            Anomonitor.logger.warn("[Anomonitor] Notifier rate limit reached (#{@limit}/min)")
+            return false
+          end
+          @timestamps << Time.current
+          true
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/notifiers/webhook.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Anomonitor
+  module Notifiers
+    class Webhook
+      def initialize(url: Anomonitor.config.webhook_url)
+        @url = url
+      end
+
+      def deliver(anomaly, event: DETECTED)
+        return false if @url.nil? || @url.to_s.strip.empty?
+
+        payload = build_payload(anomaly, event.to_s)
+        response = post_json(payload)
+        success = response.is_a?(Net::HTTPSuccess)
+
+        unless success
+          Anomonitor.logger.warn(
+            "[Anomonitor] Webhook failed: HTTP #{response&.code} #{response&.body}"
+          )
+        end
+
+        success
+      rescue StandardError => e
+        Anomonitor.logger.warn("[Anomonitor] Webhook error: #{e.message}")
+        false
+      end
+
+      def deliver_digest(payload)
+        return false if @url.nil? || @url.to_s.strip.empty?
+
+        body =
+          if slack_incoming_webhook?
+            count = payload[:count] || payload["count"] || 0
+            { text: "*Anomonitor* digest — #{count} anomalies <#{Anomonitor.config.dashboard_path}/anomalies>" }
+          else
+            payload
+          end
+        response = post_json(body)
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        Anomonitor.logger.warn("[Anomonitor] Digest webhook error: #{e.message}")
+        false
+      end
+
+      private
+
+      def build_payload(anomaly, event)
+        if slack_incoming_webhook?
+          { text: slack_text(anomaly, event) }
+        else
+          Notifiers.payload(anomaly, event: event)
+        end
+      end
+
+      def slack_incoming_webhook?
+        @url.to_s.include?("hooks.slack.com")
+      end
+
+      def slack_text(anomaly, event)
+        threshold = anomaly.threshold.nil? ? "n/a" : anomaly.threshold
+        dashboard = Anomonitor.config.anomaly_dashboard_url(anomaly.id)
+        tags = anomaly.tags.is_a?(Hash) ? anomaly.tags : {}
+        tenant = tags["tenant"] || tags[:tenant]
+        items = tags["items"] || tags[:items]
+
+        parts = ["*Anomonitor*"]
+        parts << if event == RESOLVED
+                   "resolved"
+                 elsif event == ACKED
+                   "acked"
+                 else
+                   anomaly.severity.to_s
+                 end
+        parts << "tenant `#{tenant}`" if tenant && !tenant.to_s.empty?
+        parts << "— #{anomaly.rule} on #{anomaly.source}/#{anomaly.metric}:"
+        parts << "#{anomaly.value} (threshold #{threshold})"
+        parts << "items: #{items}" if items && !items.to_s.empty?
+        parts << "<#{dashboard}>"
+        parts.join(" ")
+      end
+
+      def post_json(payload)
+        uri = URI.parse(@url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["User-Agent"] = "anomonitor/#{Anomonitor::VERSION}"
+        request.body = JSON.generate(payload)
+
+        response = http.request(request)
+        if response.is_a?(Net::HTTPServerError)
+          sleep 0.5
+          response = http.request(request)
+        end
+        response
+      end
+    end
+  end
+end

data/lib/anomonitor/notifiers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Notifiers
+    DETECTED = "anomaly.detected"
+    RESOLVED = "anomaly.resolved"
+    ACKED = "anomaly.acked"
+    DIGEST = "anomaly.digest"
+
+    module_function
+
+    def build(config = Anomonitor.config)
+      raw = config.notifier
+      notifier =
+        if raw.nil?
+          Webhook.new
+        else
+          list = Array(raw).map { |entry| wrap(entry) }
+          list.size == 1 ? list.first : Composite.new(list)
+        end
+
+      limit = config.notifier_rate_limit.to_i
+      limit.positive? ? RateLimited.new(notifier, limit_per_minute: limit) : notifier
+    end
+
+    def wrap(entry)
+      case entry
+      when Class
+        entry.new
+      else
+        if entry.respond_to?(:deliver)
+          entry
+        elsif entry.respond_to?(:call)
+          Callable.new(entry)
+        else
+          raise ArgumentError,
+                "Anomonitor notifier must respond to #deliver or #call (got #{entry.class})"
+        end
+      end
+    end
+
+    def payload(anomaly, event: DETECTED)
+      {
+        gem: "anomonitor",
+        event: event.to_s,
+        severity: anomaly.severity,
+        rule: anomaly.rule,
+        source: anomaly.source,
+        metric: anomaly.metric,
+        value: anomaly.value,
+        threshold: anomaly.threshold,
+        sampled_at: anomaly.sampled_at&.iso8601,
+        resolved_at: anomaly.resolved_at&.iso8601,
+        dashboard_url: Anomonitor.config.anomaly_dashboard_url(anomaly.id),
+        tags: anomaly.tags
+      }
+    end
+  end
+end

data/lib/anomonitor/poll_lock.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  class PollLock
+    LOCK_KEY = 8_604_071_000 # stable advisory lock id for Anomonitor
+    LOCK_FILE = "tmp/anomonitor_poll.lock"
+
+    def self.with_lock(enabled: Anomonitor.config.poll_lock)
+      return yield unless enabled
+
+      new.with_lock { yield }
+    end
+
+    def with_lock
+      if postgres?
+        with_pg_lock { yield }
+      else
+        with_file_lock { yield }
+      end
+    end
+
+    private
+
+    def postgres?
+      return false unless defined?(ActiveRecord::Base)
+
+      adapter = ActiveRecord::Base.connection.adapter_name.to_s.downcase
+      adapter.include?("postgres")
+    rescue StandardError
+      false
+    end
+
+    def with_pg_lock
+      conn = ActiveRecord::Base.connection
+      locked = conn.select_value("SELECT pg_try_advisory_lock(#{LOCK_KEY})")
+      unless locked == true || locked == "t" || locked == 1
+        Anomonitor.logger.info("[Anomonitor] Poll skipped — advisory lock held by another process")
+        return []
+      end
+
+      yield
+    ensure
+      begin
+        conn&.execute("SELECT pg_advisory_unlock(#{LOCK_KEY})")
+      rescue StandardError
+        nil
+      end
+    end
+
+    def with_file_lock
+      path = lock_path
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, File::RDWR | File::CREAT, 0o644) do |file|
+        unless file.flock(File::LOCK_EX | File::LOCK_NB)
+          Anomonitor.logger.info("[Anomonitor] Poll skipped — file lock held by another process")
+          return []
+        end
+        yield
+      end
+    end
+
+    def lock_path
+      root = defined?(Rails) && Rails.respond_to?(:root) && Rails.root ? Rails.root : Dir.pwd
+      File.join(root.to_s, LOCK_FILE)
+    end
+  end
+end

data/lib/anomonitor/poller.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "fileutils"
+
+module Anomonitor
+  class Poller
+    include Singleton
+
+    attr_reader :last_run_at, :last_error, :running
+
+    def initialize
+      @mutex = Mutex.new
+      @thread = nil
+      @running = false
+      @last_run_at = nil
+      @last_error = nil
+      @collector_status = {}
+      @last_schema_drift_at = nil
+    end
+
+    def start
+      @mutex.synchronize do
+        return if @running
+
+        @running = true
+        @thread = Thread.new { loop_poll }
+        @thread.abort_on_exception = false
+        Anomonitor.logger.info("[Anomonitor] Poller started (interval=#{Anomonitor.config.poll_interval}s)")
+      end
+    end
+
+    def stop
+      thread = nil
+      @mutex.synchronize do
+        @running = false
+        thread = @thread
+        @thread = nil
+      end
+      return unless thread
+
+      # Prefer a cooperative stop over Thread#kill mid-insert/webhook
+      thread.join(Anomonitor.config.poll_interval.to_i + 5)
+      thread.kill if thread.alive?
+    end
+
+    def tick
+      PollLock.with_lock do
+        points = collect_all
+        persist(points)
+        Detector.new.evaluate(points)
+        Mute.prune_expired! if defined?(Anomonitor::Mute)
+        prune_old_records
+        @last_run_at = Time.current
+        @last_error = nil
+        points
+      end
+    rescue StandardError => e
+      @last_error = e.message
+      Anomonitor.logger.warn("[Anomonitor] Poller tick failed: #{e.message}")
+      []
+    end
+
+    def status
+      {
+        poll_mode: Anomonitor.config.poll_mode,
+        running: @running,
+        last_run_at: effective_last_run_at,
+        last_error: @last_error,
+        collectors: @collector_status,
+        poll_interval: Anomonitor.config.poll_interval,
+        schema_drift_interval: Anomonitor.config.schema_drift_interval,
+        poll_lock: Anomonitor.config.poll_lock
+      }
+    end
+
+    private
+
+    def effective_last_run_at
+      return @last_run_at if @last_run_at
+      return nil unless defined?(Anomonitor::MetricSample)
+
+      Anomonitor::MetricSample.maximum(:sampled_at)
+    rescue StandardError
+      nil
+    end
+
+    def loop_poll
+      while @running
+        tick
+        sleep Anomonitor.config.poll_interval.to_i
+      end
+    end
+
+    def collect_all
+      points = []
+      collectors.each do |name, collector|
+        result = Array(collector.collect)
+        @collector_status[name] = { ok: true, count: result.size, at: Time.current }
+        @last_schema_drift_at = Time.current if name == :schema_drift
+        points.concat(result)
+      rescue StandardError => e
+        @collector_status[name] = { ok: false, error: e.message, at: Time.current }
+        Anomonitor.logger.warn("[Anomonitor] Collector #{name} failed: #{e.message}")
+      end
+      points
+    end
+
+    def collectors
+      list = {}
+      cfg = Anomonitor.config.collectors
+      list[:sidekiq] = Collectors::Sidekiq.new if cfg.sidekiq
+      list[:delayed_job] = Collectors::DelayedJob.new if cfg.delayed_job
+      list[:solid_queue] = Collectors::SolidQueue.new if cfg.solid_queue
+      list[:schema_drift] = Collectors::SchemaDrift.new if cfg.schema_drift && schema_drift_due?
+      Anomonitor.config.tables.each do |table|
+        list[:"table_#{table.name}"] = Collectors::Table.new(table)
+      end
+      list
+    end
+
+    def schema_drift_due?
+      interval = Anomonitor.config.schema_drift_interval.to_i
+      interval = Anomonitor.config.poll_interval.to_i if interval <= 0
+      return true if @last_schema_drift_at.nil?
+
+      Time.current - @last_schema_drift_at >= interval
+    end
+
+    def persist(points)
+      return if points.empty?
+      return unless defined?(Anomonitor::MetricSample)
+
+      rows = points.map do |p|
+        {
+          source: p.source,
+          metric: p.metric,
+          value: p.value,
+          tags: p.tags,
+          sampled_at: p.sampled_at,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+      Anomonitor::MetricSample.insert_all(rows)
+    rescue StandardError => e
+      Anomonitor.logger.warn("[Anomonitor] Failed to persist metrics: #{e.message}")
+    end
+
+    def prune_old_records
+      days = Anomonitor.config.retention_days.to_i
+      return if days <= 0
+
+      cutoff = days.days.ago
+      Anomonitor::MetricSample.where("sampled_at < ?", cutoff).delete_all
+      Anomonitor::Anomaly
+        .where("created_at < ?", cutoff)
+        .where("NOT (source = ? AND resolved_at IS NULL)", "schema_drift")
+        .delete_all
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/anomonitor/tenancy.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  # Resolves tenant schema names and switches connection context.
+  #
+  #   Anomonitor.configure do |c|
+  #     c.tenants = -> { CustomerTenant.pluck(:name) }
+  #     c.exclude_tenants = %w[public]
+  #     c.tenant_switch = ->(name, &block) { Apartment::Tenant.switch(name, &block) }
+  #   end
+  module Tenancy
+    module_function
+
+    def tenant_names
+      cfg = Anomonitor.config
+      raw = cfg.tenants
+      list =
+        case raw
+        when Proc then Array(raw.call)
+        when nil then []
+        else Array(raw)
+        end
+
+      excluded = Array(cfg.exclude_tenants).map(&:to_s)
+      list.map(&:to_s).reject { |name| name.empty? || excluded.include?(name) }.uniq.sort
+    rescue StandardError => e
+      Anomonitor.logger.warn("[Anomonitor] Failed to resolve tenants: #{e.message}")
+      []
+    end
+
+    def switch(name, &block)
+      switcher = Anomonitor.config.tenant_switch
+      if switcher
+        switcher.call(name, &block)
+      elsif defined?(::Apartment::Tenant)
+        ::Apartment::Tenant.switch(name, &block)
+      else
+        yield
+      end
+    end
+
+    def multi_tenant?
+      tenant_names.any?
+    end
+  end
+end

data/lib/anomonitor/version.rb

@@ -0,0 +1,3 @@
+module Anomonitor
+  VERSION = "0.6.1"
+end