sillydev 1.0.0

data/lib/sillydev/monitoring/discordrb.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../monitoring"
+
+module SillyDev
+  module Monitoring
+    # discordrb integration.
+    #
+    #   require "discordrb"
+    #   require "sillydev/monitoring/discordrb"
+    #
+    #   SillyDev::Monitoring.init
+    #   bot = Discordrb::Commands::CommandBot.new(token: ENV["TOKEN"], prefix: "!")
+    #   SillyDev::Monitoring::Discordrb.monitor(bot)
+    #
+    # Records discord.command.duration (tags command, outcome = ok/error) for prefix commands and
+    # application (slash) commands, reports errors raised in event handlers and commands, and sends
+    # the discord.guilds gauge every window. Errors still reach discordrb's own logging as before.
+    # Loading this file does not load discordrb.
+    module Discordrb
+      module_function
+
+      # Instruments a Discordrb::Bot or Discordrb::Commands::CommandBot. Returns it.
+      def monitor(bot)
+        return bot if bot.instance_variable_defined?(:@__sillydev_monitoring)
+
+        bot.instance_variable_set(:@__sillydev_monitoring, true)
+        bot.singleton_class.prepend(EventHook) if bot.respond_to?(:call_event, true)
+        bot.singleton_class.prepend(CommandHook) if bot.respond_to?(:execute_command, true)
+        bot_ref = bot
+        collector = lambda do |client|
+          servers = bot_ref.instance_variable_get(:@servers)
+          client.gauge("discord.guilds", servers.size) if servers.respond_to?(:size)
+        end
+        Monitoring.collectors << collector
+        bot
+      end
+
+      def record(command, ms, outcome)
+        Monitoring.timing("discord.command.duration", ms, tags: { "command" => command, "outcome" => outcome })
+        client = Monitoring.client
+        return unless client && ms >= client.slow_threshold_ms
+
+        Monitoring.record_slow(command, ms, kind: "discord", tags: { "outcome" => outcome })
+      end
+
+      def context(event)
+        out = {}
+        server = event.respond_to?(:server) ? event.server : nil
+        channel = event.respond_to?(:channel) ? event.channel : nil
+        out["guild_id"] = server.id.to_s if server.respond_to?(:id)
+        out["channel_id"] = channel.id.to_s if channel.respond_to?(:id)
+        out
+      rescue StandardError
+        {}
+      end
+
+      def application_command_name(event)
+        return nil unless event.class.name.to_s.end_with?("ApplicationCommandEvent") && event.respond_to?(:command_name)
+
+        [event.command_name, event.respond_to?(:subcommand_group) ? event.subcommand_group : nil,
+         event.respond_to?(:subcommand) ? event.subcommand : nil].compact.join(" ")
+      end
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # Wraps an event handler so its run is timed (for application commands) and its errors are
+      # reported, then raised again for discordrb to log.
+      class Handler
+        def initialize(handler)
+          @handler = handler
+        end
+
+        def call(event)
+          return @handler.call(event) unless Monitoring.enabled?
+
+          command = Discordrb.application_command_name(event)
+          start = Discordrb.now
+          begin
+            result = @handler.call(event)
+            Discordrb.record(command, (Discordrb.now - start) * 1000.0, "ok") if command
+            result
+          rescue StandardError => e
+            Discordrb.record(command, (Discordrb.now - start) * 1000.0, "error") if command
+            tags = command ? { "command" => command } : { "event" => event.class.name.to_s.split("::").last }
+            Monitoring.capture_exception(e, handled: false, tags: tags, context: Discordrb.context(event))
+            raise
+          end
+        end
+
+        def respond_to_missing?(name, include_all = false)
+          @handler.respond_to?(name, include_all)
+        end
+
+        def method_missing(name, ...)
+          @handler.respond_to?(name) ? @handler.public_send(name, ...) : super
+        end
+      end
+
+      # Prepended to the bot: runs every handler through Handler.
+      module EventHook
+        private
+
+        def call_event(handler, event)
+          super(Handler.new(handler), event)
+        end
+      end
+
+      # Prepended to a CommandBot: times prefix commands.
+      module CommandHook
+        def execute_command(name, event, *rest)
+          return super unless Monitoring.enabled?
+
+          start = Discordrb.now
+          begin
+            result = super
+            Discordrb.record(name.to_s, (Discordrb.now - start) * 1000.0, "ok")
+            result
+          rescue StandardError => e
+            Discordrb.record(name.to_s, (Discordrb.now - start) * 1000.0, "error")
+            Monitoring.capture_exception(e, handled: false, tags: { "command" => name.to_s },
+                                            context: Discordrb.context(event))
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sillydev/monitoring/http.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SillyDev
+  module Monitoring
+    # Helpers shared by the HTTP integrations.
+    module HTTP
+      ID_SEGMENT = /\A(?:\d+|\h{8}-\h{4}-\h{4}-\h{4}-\h{12}|\h{8,}|[A-Za-z0-9_-]{24,})\z/
+
+      module_function
+
+      def status_class(status)
+        return "5xx" if status.nil? || status < 100 || status > 599
+
+        "#{status / 100}xx"
+      end
+
+      # A route-like path for apps whose router gives no template: ids become :id. Keeps the number
+      # of series down (each distinct route is a series).
+      def normalize_path(path)
+        path = (path.nil? || path.empty? ? "/" : path).split("?", 2).first
+        parts = path.split("/", -1).map { |part| ID_SEGMENT.match?(part) ? ":id" : part }
+        joined = parts.join("/")
+        (joined.empty? ? "/" : joined)[0, 200]
+      end
+
+      def route_label(method, template)
+        "#{method.to_s.upcase} #{template}"[0, 64]
+      end
+    end
+  end
+end

data/lib/sillydev/monitoring/rack.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../monitoring"
+require_relative "http"
+
+module SillyDev
+  module Monitoring
+    # Rack middleware (Rails, Sinatra, Hanami, Roda and any other Rack app).
+    #
+    #   # config.ru
+    #   require "sillydev/monitoring/rack"
+    #   SillyDev::Monitoring.init
+    #   use SillyDev::Monitoring::Rack
+    #
+    # Rails apps can require "sillydev/monitoring/rails" instead, which adds it for you. Records
+    # http.server.duration (tags route, method, status), reports unhandled exceptions and slow
+    # requests. The route is the router's template where Rails (7.1 and later) or Sinatra say it;
+    # otherwise the path with ids replaced by :id. Call Rack.set_route(env, "/orders/:id") to name it
+    # yourself.
+    class Rack
+      ROUTE_KEY = "sillydev.monitoring.route"
+
+      def self.set_route(env, template)
+        env[ROUTE_KEY] = template
+      end
+
+      def initialize(app, slow_threshold_ms: nil, route_name: nil)
+        @app = app
+        @slow_threshold_ms = slow_threshold_ms
+        @route_name = route_name
+      end
+
+      def call(env)
+        return @app.call(env) unless Monitoring.enabled?
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          status, headers, body = @app.call(env)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          record(env, nil, start, e)
+          raise
+        end
+        [status, headers, BodyProxy.new(body) { record(env, status.to_i, start, nil) }]
+      end
+
+      # Calls the block once the server has closed the body, so the time includes sending it.
+      class BodyProxy
+        def initialize(body, &done)
+          @body = body
+          @done = done
+          @finished = false
+        end
+
+        def respond_to_missing?(name, include_all = false)
+          name != :to_ary && @body.respond_to?(name, include_all)
+        end
+
+        def method_missing(name, ...)
+          return super if name == :to_ary
+
+          @body.__send__(name, ...)
+        end
+
+        def each(&)
+          @body.each(&)
+        end
+
+        def close
+          @body.close if @body.respond_to?(:close)
+        ensure
+          unless @finished
+            @finished = true
+            @done.call
+          end
+        end
+      end
+
+      private
+
+      def record(env, status, start, failed)
+        ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
+        status = 500 if failed && (status.nil? || status < 500)
+        # Rails and Sinatra render an exception into a 500 before it reaches here, and keep it in the env.
+        failed ||= env["action_dispatch.exception"] || env["sinatra.error"] if status && status >= 500
+        method = env["REQUEST_METHOD"].to_s.upcase
+        method = "GET" if method.empty?
+        route = HTTP.route_label(method, template(env, status))
+        Monitoring.timing("http.server.duration", ms,
+                          tags: { "route" => route, "method" => method, "status" => HTTP.status_class(status) })
+        Monitoring.capture_exception(failed, handled: false, tags: { "route" => route, "method" => method }) if failed.is_a?(Exception)
+        client = Monitoring.client
+        threshold = @slow_threshold_ms || (client ? client.slow_threshold_ms : 1000)
+        Monitoring.record_slow(route, ms, kind: "http", tags: { "status" => (status || 500).to_s }) if ms >= threshold
+      rescue StandardError
+        nil
+      end
+
+      def template(env, status)
+        named = @route_name&.call(env)
+        return named.to_s if named
+
+        route = env[ROUTE_KEY] || env["action_dispatch.route_uri_pattern"]
+        return route.to_s.sub(/\(\.:format\)\z/, "") if route
+
+        sinatra = env["sinatra.route"]
+        return sinatra.to_s.split(" ", 2).last if sinatra
+
+        return "<unmatched>" if status == 404
+
+        HTTP.normalize_path("#{env['SCRIPT_NAME']}#{env['PATH_INFO']}")
+      end
+    end
+  end
+end

data/lib/sillydev/monitoring/rails.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "rack"
+
+module SillyDev
+  module Monitoring
+    # Rails integration: adds SillyDev::Monitoring::Rack to the app's middleware and reports the
+    # errors Rails.error sees (Rails 7 and later). Monitoring still does nothing until
+    # SillyDev::Monitoring.init is called, for example in config/initializers/sillydev.rb:
+    #
+    #   # Gemfile
+    #   gem "sillydev", require: ["sillydev", "sillydev/monitoring/rails"]
+    #
+    #   # config/initializers/sillydev.rb
+    #   SillyDev::Monitoring.init(service: "web")
+    class Railtie < ::Rails::Railtie
+      initializer "sillydev.monitoring.middleware" do |app|
+        app.middleware.insert(0, SillyDev::Monitoring::Rack)
+      end
+
+      config.after_initialize do
+        if defined?(::Rails.error) && ::Rails.error.respond_to?(:subscribe)
+          ::Rails.error.subscribe(SillyDev::Monitoring::Railtie::ErrorSubscriber.new)
+        end
+      end
+
+      # Passes errors reported through Rails.error (Rails.error.handle, .record and .report, and the
+      # jobs and requests Rails reports itself) to monitoring.
+      class ErrorSubscriber
+        def report(error, handled:, severity: nil, context: {}, source: nil)
+          tags = {}
+          tags["severity"] = severity.to_s if severity
+          tags["source"] = source.to_s if source
+          SillyDev::Monitoring.capture_exception(error, handled: handled, tags: tags, context: context)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sillydev/monitoring/runtime.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module SillyDev
+  module Monitoring
+    # Process and runtime metrics, sampled once per flush window by the client's thread.
+    class RuntimeCollector
+      def initialize
+        reset
+      end
+
+      # Starts again from now (in a child process after fork).
+      def reset
+        @wall = monotonic
+        @cpu = cpu_time
+        @gc_count = GC.count
+        @gc_time = gc_time
+        @started = process_start
+      end
+
+      # [[name, type, value], ...]
+      def collect
+        samples = []
+        wall = monotonic
+        cpu = cpu_time
+        samples << ["process.cpu.percent", "gauge", ((cpu - @cpu) / (wall - @wall) * 100.0).round(3)] if wall > @wall
+        @wall = wall
+        @cpu = cpu
+
+        rss = self.rss
+        samples << ["process.memory.rss", "gauge", rss] if rss
+
+        count = GC.count
+        collections = [count - @gc_count, 0].max
+        samples << ["runtime.gc.count", "counter", collections.to_f]
+        time = gc_time
+        if time && @gc_time && collections.positive?
+          # Ruby keeps the total time spent in GC, not each pause: record the average pause once
+          # per collection in the window.
+          average = [(time - @gc_time).to_f / collections, 0.0].max
+          [collections, 1000].min.times { samples << ["runtime.gc.pause", "histogram", average] }
+        end
+        @gc_count = count
+        @gc_time = time
+
+        samples << ["process.threads", "gauge", Thread.list.size.to_f]
+        samples << ["process.uptime", "gauge", [Time.now.to_f - @started, 0.0].max.round(3)]
+        samples
+      end
+
+      def rss
+        statm = File.read("/proc/self/statm").split
+        statm[1].to_i * page_size.to_f
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def cpu_time
+        Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
+      end
+
+      # Milliseconds spent in GC so far, where Ruby keeps it (3.1 and later).
+      def gc_time
+        GC.stat(:time)
+      rescue ArgumentError
+        nil
+      end
+
+      def page_size
+        @page_size ||= begin
+          Etc.sysconf(Etc::SC_PAGESIZE)
+        rescue StandardError
+          4096
+        end
+      end
+
+      # Wall-clock time the process started (falls back to now).
+      def process_start
+        fields = File.read("/proc/self/stat").split(")").last.split
+        start_ticks = fields[19].to_i
+        uptime = File.read("/proc/uptime").split.first.to_f
+        ticks = Etc.sysconf(Etc::SC_CLK_TCK)
+        Time.now.to_f - (uptime - (start_ticks.to_f / ticks))
+      rescue StandardError
+        Time.now.to_f
+      end
+    end
+  end
+end

data/lib/sillydev/monitoring/serialize.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "json"
+require "rbconfig"
+require "set"
+
+module SillyDev
+  module Monitoring
+    # Turning names, tags, exceptions and attributes into the shapes of feathers/docs/ingest.md.
+    module Serialize
+      NAME_RE = /\A[a-z][a-z0-9_.]{0,99}\z/
+      TAG_KEY_RE = /\A[a-z_][a-z0-9_.]{0,31}\z/
+      SENSITIVE_RE = /password|passwd|secret|token|authorization|cookie|api[_-]?key/i
+      REDACTED = "[redacted]"
+
+      MAX_TAGS = 8
+      MAX_TAG_VALUE = 64
+      MAX_TYPE = 128
+      MAX_MESSAGE = 1024
+      MAX_FRAME_FIELD = 256
+      MAX_FRAMES = 64
+      MAX_CONTEXT_BYTES = 16 * 1024
+      MAX_ATTRIBUTES_BYTES = 4 * 1024
+      MAX_FINGERPRINT = 128
+      SLOW_KINDS = %w[http discord task custom].freeze
+
+      module_function
+
+      def valid_name?(name)
+        name.is_a?(String) && NAME_RE.match?(name)
+      end
+
+      # Makes a metric name out of arbitrary text.
+      def to_name(text)
+        name = text.to_s.downcase.gsub(/[^a-z0-9_.]+/, "_").gsub(/\A[_.]+|[_.]+\z/, "").gsub(/\.{2,}/, ".")
+        name = "fn.#{name}" if name.empty? || !name[0].match?(/[a-z]/)
+        name = name[0, 100].sub(/\.+\z/, "")
+        name.empty? ? "fn" : name
+      end
+
+      def text(value)
+        return value if value.is_a?(String)
+        return value.to_s if value.is_a?(Symbol)
+
+        JSON.generate(value)
+      rescue StandardError
+        value.to_s
+      end
+
+      # At most 8 valid tags as sorted [key, value] pairs, values as strings of at most 64
+      # characters, sensitive keys redacted.
+      def clean_tags(tags)
+        return [] if tags.nil? || tags.empty?
+
+        out = {}
+        tags.each do |key, value|
+          key = key.to_s if key.is_a?(Symbol)
+          next unless key.is_a?(String) && TAG_KEY_RE.match?(key)
+
+          out[key] = SENSITIVE_RE.match?(key) ? REDACTED : text(value)[0, MAX_TAG_VALUE]
+        end
+        out.sort.first(MAX_TAGS).freeze
+      end
+
+      # A JSON-safe copy of value with the values of sensitive keys replaced.
+      def redact(value, depth = 0)
+        return "[too deep]" if depth > 8
+
+        case value
+        when Hash
+          value.to_h { |k, v| [k.to_s, SENSITIVE_RE.match?(k.to_s) ? REDACTED : redact(v, depth + 1)] }
+        when Array, Set then value.map { |v| redact(v, depth + 1) }
+        when nil, true, false, Integer, String then value
+        when Float then value.finite? ? value : value.to_s
+        else value.to_s
+        end
+      end
+
+      # A redacted JSON object, or {"_truncated" => true} when its JSON text is over limit bytes.
+      def bounded_object(value, limit)
+        return {} if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+        value = { "value" => value } unless value.is_a?(Hash)
+        cleaned = redact(value)
+        JSON.generate(cleaned).bytesize > limit ? { "_truncated" => true } : cleaned
+      end
+
+      LIBRARY_DIRS = [RbConfig::CONFIG["rubylibdir"], RbConfig::CONFIG["rubyarchdir"]].compact.map do |dir|
+        File.expand_path(dir)
+      end.freeze
+
+      # [path to report, in_app] for a frame's file.
+      def split_path(path)
+        return [path.to_s, false] if path.nil? || path.start_with?("<") || path.start_with?("(")
+
+        normalized = path.tr("\\", "/")
+        if (index = normalized.rindex("/gems/"))
+          rest = normalized[(index + 6)..]
+          return [rest, false]
+        end
+        full = File.expand_path(path)
+        LIBRARY_DIRS.each do |lib|
+          return [full.delete_prefix("#{lib}/"), false] if full.start_with?("#{lib}/")
+        end
+        cwd = Dir.pwd
+        return [full.delete_prefix("#{cwd}/"), true] if full.start_with?("#{cwd}/")
+
+        [normalized, true]
+      rescue StandardError
+        [path.to_s, true]
+      end
+
+      OWN_DIR = File.expand_path("../..", __dir__)
+
+      # Frames innermost first, at most 64.
+      def stack_frames(exception)
+        locations = exception.backtrace_locations
+        if locations
+          locations.first(MAX_FRAMES).map do |location|
+            frame(location.absolute_path || location.path, location.lineno, location.label)
+          end
+        else
+          (exception.backtrace || []).first(MAX_FRAMES).map do |line|
+            path, lineno, label = line.match(/\A(.*?):(\d+)(?::in [`'](.*)')?\z/)&.captures
+            frame(path || line, lineno.to_i, label)
+          end
+        end
+      end
+
+      def frame(path, lineno, label)
+        file, in_app = split_path(path.to_s)
+        in_app = false if path.to_s.start_with?("#{OWN_DIR}/")
+        {
+          "file" => file[0, MAX_FRAME_FIELD],
+          "function" => label.to_s[0, MAX_FRAME_FIELD],
+          "line" => lineno,
+          "column" => nil,
+          "module" => nil,
+          "in_app" => in_app,
+        }
+      end
+
+      def exception_type(exception)
+        (exception.class.name || exception.class.to_s)[0, MAX_TYPE]
+      end
+
+      def exception_message(exception)
+        exception.message.to_s[0, MAX_MESSAGE]
+      rescue StandardError
+        "<unprintable exception>"
+      end
+
+      def serialize_exception(exception)
+        item = {
+          "type" => exception_type(exception),
+          "message" => exception_message(exception),
+          "stack" => stack_frames(exception),
+        }
+        cause = exception.cause
+        if cause && !cause.equal?(exception)
+          item["cause"] = { "type" => exception_type(cause), "message" => exception_message(cause),
+                            "stack" => stack_frames(cause) }
+        end
+        item
+      end
+    end
+  end
+end