spartan_apm 0.0.0.rc1

data/lib/spartan_apm/web/router.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module SpartanAPM
+  module Web
+    # Rack application for serving up the web UI. The application can either
+    # be mounted as a Rack application or as Rack middleware.
+    class Router
+      ASSET_ROOT_DIR = File.expand_path(File.join(__dir__, "..", "..", "..", "app", "assets"))
+
+      def initialize(app = nil, root_path = "")
+        @app = app
+        @root_path = root_path.chomp("/")
+        @root_prefix = "#{@root_path}/"
+      end
+
+      def call(env)
+        path = env["PATH_INFO"]
+        response = nil
+        if path.start_with?(@root_path)
+          app_path = path[@root_path.length, path.length]
+          request = Rack::Request.new(env)
+          case app_path
+          when ""
+            response = [302, {"Location" => root_url(request)}, []]
+          when "/"
+            body = Helpers.new(request).render("index.html.erb")
+            response = [200, {"Content-Type" => "text/html; charset=utf-8"}, [body]]
+          when "/metrics"
+            response = json_response(ApiRequest.new(request).metrics)
+          when "/live_metrics"
+            response = json_response(ApiRequest.new(request).live_metrics)
+          when "/errors"
+            response = json_response(ApiRequest.new(request).errors)
+          when "/actions"
+            response = json_response(ApiRequest.new(request).actions)
+          else
+            if app_path.start_with?("/assets/")
+              response = asset_response(app_path.sub("/assets/", ""))
+            end
+          end
+        end
+
+        if response
+          response
+        elsif @app.nil?
+          not_found_response
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def not_found_response
+        [404, {"Content-Type" => "text/plain"}, ["Not found"]]
+      end
+
+      def json_response(result)
+        [200, {"Content-Type" => "application/json; charset=utf-8"}, [JSON.dump(result)]]
+      end
+
+      def asset_response(asset_path)
+        file_path = File.expand_path(File.join(ASSET_ROOT_DIR, asset_path.split("/")))
+        return nil unless file_path.start_with?(ASSET_ROOT_DIR) && File.exist?(file_path)
+        data = File.read(file_path)
+        headers = {"Content-Type" => mime_type(file_path)}
+        headers["Cache-Control"] = "max-age=604800" if asset_path.match?(/\d\./)
+        [200, headers, [data]]
+      end
+
+      def mime_type(file_path)
+        extension = file_path.split(".").last
+        case extension
+        when "css"
+          "text/css"
+        when "js"
+          "application/javascript"
+        else
+          "application/octet-stream"
+        end
+      end
+
+      def root_url(request)
+        request.url.sub(/$|(\?.*)/, '/\1')
+      end
+    end
+  end
+end

data/lib/spartan_apm/web.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SpartanAPM
+  module Web
+  end
+end
+
+require_relative "web/api_request"
+require_relative "web/helpers"
+require_relative "web/router"

data/lib/spartan_apm.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require "set"
+require "digest"
+require "zlib"
+require "time"
+require "json"
+
+require "redis"
+require "msgpack"
+require "concurrent-ruby"
+require "rack"
+
+module SpartanAPM
+  DEFAULT_TTL = 60 * 60 * 24 * 7
+
+  # These are the default locations of javascript and CSS assets.
+  @plotly_js_url = ENV.fetch("SPARTAN_APM_PLOTLY_JS_URL", "https://cdn.plot.ly/plotly-basic-2.9.0.min.js")
+
+  @ignore_patterns = {}
+
+  @max_actions = 100
+
+  class << self
+    # The configure method is just syntactic sugar to call a block that yields this module.
+    # ```
+    # SpartanAPM.configure do |config|
+    #   config.env = "production"
+    #   config.sample_rate = 0.1
+    # end
+    # ```
+    def configure
+      yield self
+    end
+
+    # Set the environment name for the application. This can be used if you want to share
+    # the same Redis server between different environments. For instance if you have multiple
+    # staging environments, you could have them all share a single Redis rather than have to
+    # stand up a dedicated one for each environment. The value can also be set with the
+    # SPARTAN_APM_ENV environment variable.
+    def env=(value)
+      value = value.to_s.dup.freeze
+      raise ArgumentError.new("env cannot contain a tilda") if value.include?("~")
+      @_env_set = true
+      @env = value
+    end
+
+    # @return [String] The environment name for the application.
+    def env
+      @env ||= ENV.fetch("SPARTAN_APM_ENV", "default")
+    end
+
+    # @api private
+    def env_set?
+      !!(defined?(@_env_set) && @_env_set)
+    end
+
+    # Set the list of available environments for the Web UI. This is only useful if there
+    # are multiple environments being saved to the same Redis database.
+    # @param value [Array<String>] List of environments.
+    def environments=(value)
+      @environments = Array(value).collect(&:to_s)
+    end
+
+    # Get the list of environments being tracked. This is used in the web UI to allow switching
+    # between multiple environments that are being stored to the same Redis database.
+    # @return [Array<String>] List of environments.
+    def environments
+      @environments ||= ENV.fetch("SPARTAN_APM_ENVIRONMENTS", env).split(/\s*,\s*/)
+    end
+
+    # Set the sample rate for monitoring. If your application gets a lot traffic, you
+    # can use this setting to only record a percentage of it rather than every single
+    # request. The value can also be set with the SPARTAN_APM_SAMPLE_RATE environment
+    # variable
+    def sample_rate=(value)
+      @sample_rate = value&.to_f
+    end
+
+    # @return [Float] The sample rate for the application.
+    def sample_rate
+      @sample_rate ||= ENV.fetch("SPARTAN_APM_SAMPLE_RATE", "1.0").to_f
+    end
+
+    # Set the time to live in seconds for how long data will be stored in Redis.
+    # The value can also be set with the SPARTAN_APM_TTL environment variable.
+    def ttl=(value)
+      value = value.to_i
+      raise ArgumentError.new("ttl must be > 0") if value < 0
+      @ttl = value
+    end
+
+    # @return [Integer] The time to live in seconds for how long data will be persisted in Redis.
+    def ttl
+      unless defined?(@ttl)
+        value = ENV["SPARTAN_APM_TTL"].to_i
+        value = DEFAULT_TTL if value <= 0
+        @ttl = value
+      end
+      @ttl
+    end
+
+    # Maximum number of actions that will be tracked. If more actions than this are being
+    # used by the application, then only the top most used actions by request time will
+    # be tracked.
+    attr_accessor :max_actions
+
+    # Set a Logger object where events can be logged. You can set this if you want
+    # to record how long it takes to persist the instrumentation data to Redis.
+    attr_writer :logger
+
+    # @return [Logger]
+    def logger
+      @logger = nil unless defined?(@logger)
+      @logger
+    end
+
+    # Set an optional application name to show in the web UI.
+    attr_writer :application_name
+
+    def application_name
+      @application_name ||= ENV.fetch("SPARTAN_APM_APPLICATION_NAME", "SpartanAPM")
+    end
+
+    # Set an option URL for a link in the web UI header.
+    attr_accessor :application_url
+
+    # URL for authenticating access to the application. This would normally be some kind of
+    # login page. Browsers will be redirected here if they are denied access to the web UI.
+    attr_accessor :authentication_url
+
+    # Set the list of app names to show in the web UI.
+    def apps=(value)
+      @apps = Array(value).collect(&:to_s)
+    end
+
+    def apps
+      @apps ||= ENV.fetch("SPARTAN_APM_APPS", "").split(/\s*,\s*/)
+    end
+
+    # Set a list of errors to ignore. If an error matches a designated class,
+    # then it will not be recorded as an error. You can use this to strip out
+    # expected errors so they don't show up in the error monitoring.
+    # @param error_classes [Class, Module, String] class, class name, or module to ignore
+    def ignore_errors(error_classes)
+      error_classes = Array(error_classes)
+      @ignore_error_modules = error_classes.select { |klass| klass.is_a?(Module) }
+      @ignore_error_class_names = Set.new(error_classes.reject { |klass| klass.is_a?(Module) })
+    end
+
+    # @return [Boolean] Returns true if the error matches an error class specified with ignore_errors.
+    def ignore_error?(error)
+      return false unless defined?(@ignore_error_class_names) && @ignore_error_class_names
+      return true if @ignore_error_modules.any? { |klass| error.is_a?(klass) }
+      return false if @ignore_error_class_names.empty?
+      ignore_error = false
+      klass = error.class
+      while klass && klass.superclass != klass
+        if @ignore_error_class_names.include?(klass.name)
+          ignore_error = true
+          break
+        end
+        klass = klass.superclass
+      end
+      ignore_error
+    end
+
+    # A backtrace cleaner can be set with a Proc (or anything that responds to `call`) to
+    # remove extraneous lines from error backtraces. Setting up a backtrace cleaner
+    # can save space in redis and make the traces easier to follow by removing uninteresting
+    # lines. The Proc will take a backtrace as an array and should return an array.
+    attr_writer :backtrace_cleaner
+
+    # Clean an error backtrace by passing it to the backtrace cleaner if one was set.
+    def clean_backtrace(backtrace)
+      if defined?(@backtrace_cleaner) && @backtrace_cleaner && backtrace
+        cleaned = Array(@backtrace_cleaner.call(backtrace[1, backtrace.size]))
+        # Alway make sure the top line of the trace is included.
+        cleaned.unshift(backtrace[0])
+        cleaned
+      else
+        backtrace
+      end
+    end
+
+    # The measure block should be wrapped around whatever you want to consider a request
+    # in your application (i.e. web request, asynchronous job execution, etc.). This method
+    # will collect all instrumentation stats that occur within the block and report them
+    # as a single unit.
+    #
+    # In order to measure both an app name and an action name need to be provided. The app
+    # name should be something that describes the application function (i.e. "web" for web
+    # requests) while the action should describe the particular action being taken by the
+    # request (i.e. controller and action for a web request, worker name for an asynchronous
+    # job, etc.).
+    #
+    # The action name is optional here, but it is required in order for metrics to
+    # be recorded. This is because a measure block should encompass as much of the request
+    # as possible in order to be accurate. However, this might be before the action name
+    # is known. The action can be provided retroactively from within the block by setting
+    # `SpartanAPM.current_action`.
+    #
+    # @param app [String, Symbol] The name of the app that is collecting metrics.
+    # @param action [String, Symbol] The name of the action that is being performed.
+    def measure(app, action = nil)
+      if Thread.current[:spartan_apm_measure].nil? && (sample_rate >= 1.0 || rand < sample_rate)
+        measure = Measure.new(app, action)
+        Thread.current[:spartan_apm_measure] = measure
+        # rubocop:disable Lint/RescueException
+        begin
+          yield
+        rescue Exception => e
+          measure.capture_error(e) unless ignore_error?(e)
+          raise
+        ensure
+          Thread.current[:spartan_apm_measure] = nil
+          measure.record!
+        end
+        # rubocop:enable Lint/RescueException
+      else
+        yield
+      end
+    end
+
+    # Set the action name for the current measure. This allows you to set up a measure
+    # before you know the action name and then provide it later once that information
+    # is available.
+    # @param action [String, Symbol]
+    def current_action=(action)
+      measure = Thread.current[:spartan_apm_measure]
+      measure.action = action if measure
+    end
+
+    # Set the app name for the current measure. This allows you to set up a measure
+    # and override the app name if you want to segment some of your requests into a
+    # different app.
+    # @param app [String, Symbol]
+    def current_app=(app)
+      measure = Thread.current[:spartan_apm_measure]
+      measure.app = app if measure
+    end
+
+    # Capture a metric for a block. The metric value recorded will be the amount of time
+    # in seconds elapsed during block execution and will be stored with the current
+    # measure.
+    #
+    # The exclusive flag can be set to true to indicate that no other components should
+    # be captured in the block. This can be used if you want to measure one component
+    # as a unit but that component calls other instrumented components. For example, if you
+    # are instrumenting HTTP requests, but also want to instrument a service call that makes
+    # an HTTP request, you would capture the service call as exclusive.
+    #
+    # @param name [String, Symbol] The name of the component being measured.
+    # @param exclusive [Boolean]
+    def capture(name, exclusive: false)
+      measure = Thread.current[:spartan_apm_measure]
+      if measure
+        measure.capture(name, exclusive: exclusive) { yield }
+      else
+        yield
+      end
+    end
+
+    # Capture a time for a component in the current measure. This is the same as calling
+    # `capture` but without a block and passing the value explicitly.
+    def capture_time(name, elapsed_time)
+      measure = Thread.current[:spartan_apm_measure]
+      measure&.capture_time(name, elapsed_time)
+    end
+
+    # Capture an error in the current measure.
+    def capture_error(error)
+      measure = Thread.current[:spartan_apm_measure]
+      if measure && !ignore_error?(error)
+        measure.capture_error(error)
+      end
+    end
+
+    # Set the host name for the current process. Defaults to the system host name.
+    attr_writer :host
+
+    # @return The host name.
+    def host
+      @host ||= Socket.gethostname
+    end
+
+    # Set the Redis instance to use for storing metrics. This can be either a Redis
+    # instance or a Proc that returns a Redis instance. If it is a Proc, the Proc
+    # will be be called at runtime.
+    #
+    # If the Redis instance is not explicitly set, then the default connection URL
+    # will be looked up from environment variables. If the value of `SPARTAN_APM_REDIS_URL_PROVIDER`
+    # is set, then the URL will be gotten from the named environment variable. Otherwise
+    # it will use the value in `REDIS_URL`.
+    attr_writer :redis
+
+    # @return [Redis] Redis instance where metrics are stored.
+    def redis
+      @redis ||= default_redis
+      @redis.is_a?(Proc) ? @redis.call : @redis
+    end
+
+    # Set a list of patterns to ignore for an app. Patterns can be passed in as either
+    # a string to match or a Regexp. Strings can be specified with wildcards using "*"
+    # (i.e. "/debug/*" would match "/debug/info", etc.).
+    # @param app [String, Symbol] The app name the patterns are for.
+    # @param patterns [String, Regexp] Patterns to match that should be ignored.
+    def ignore_requests(app, *patterns)
+      app = app.to_s
+      patterns = patterns.compact
+      if patterns.empty?
+        @ignore_patterns.delete(app)
+      else
+        regexp_patterns = patterns.flatten.collect do |pattern|
+          if pattern.is_a?(Regexp)
+            pattern
+          else
+            exp = Regexp.escape(pattern).gsub("\\*", "(?:.*)")
+            Regexp.new("\\A#{exp}\\z")
+          end
+        end
+        @ignore_patterns[app] = Regexp.union(regexp_patterns)
+      end
+    end
+
+    # Determine if a value is set to be ignored. This method should be called
+    # by whatever code is calling `measure`. There is no set definition for what the
+    # value being passed should be and it left up to the implementation to set
+    # a convention.
+    #
+    # For instance in the bundled Rack implementation, the value passed to this
+    # method is the web request path. This allows that implementation to disable
+    # instrumentation for a set of request paths.
+    def ignore_request?(app, value)
+      return false if value.nil?
+      !!@ignore_patterns[app.to_s]&.match(value.to_s)
+    end
+
+    # The web UI will use a locked version of the plotly.js library from the official
+    # distribution CDN. If your company security policy requires all tools to pull
+    # from an internal source, you can change the URL with this setting.
+    attr_accessor :plotly_js_url
+
+    # @api private
+    # Get the bucket for the specified time.
+    # @return [Integer]
+    def bucket(time)
+      (time.to_f / 60.0).floor
+    end
+
+    # @api private
+    # Get the time for the specified bucket.
+    # @return [Time]
+    def bucket_time(bucket)
+      Time.at(bucket * 60.0)
+    end
+
+    # @api private
+    # Used for testing for disabling asynchronous metric persistence.
+    def persist_asynchronously?
+      unless defined?(@persist_asynchronously)
+        @persist_asynchronously = true
+      end
+      @persist_asynchronously
+    end
+
+    # @api private
+    # Used for testing for disabling asynchronous metric persistence.
+    def persist_asynchronously=(value)
+      @persist_asynchronously = !!value
+    end
+
+    private
+
+    def default_redis
+      var_name = ENV.fetch("SPARTAN_APM_REDIS_URL_PROVIDER", "REDIS_URL")
+      url = ENV[var_name]
+      Redis.new(url: url)
+    end
+  end
+end
+
+require_relative "spartan_apm/string_cache"
+require_relative "spartan_apm/error_info"
+require_relative "spartan_apm/measure"
+require_relative "spartan_apm/persistence"
+require_relative "spartan_apm/report"
+require_relative "spartan_apm/metric"
+require_relative "spartan_apm/instrumentation"
+require_relative "spartan_apm/middleware"
+require_relative "spartan_apm/web"
+
+if defined?(Rails::Engine)
+  require_relative "spartan_apm/engine"
+end
+
+at_exit do
+  SpartanAPM::Measure.flush
+end

data/spartan_apm.gemspec

@@ -0,0 +1,39 @@
+Gem::Specification.new do |spec|
+  spec.name = "spartan_apm"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Simple redis backed application performance monitoring tool."
+  spec.homepage = "https://github.com/bdurand/spartan_apm"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    docker/
+    gemfiles/
+    sample_data
+    spec/
+  ]
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis"
+  spec.add_dependency "msgpack"
+  spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "rack"
+
+  spec.add_development_dependency "bundler"
+
+  spec.required_ruby_version = ">= 2.5"
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: spartan_apm
+version: !ruby/object:Gem::Version
+  version: 0.0.0.rc1
+platform: ruby
+authors:
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- VERSION
+- app/assets/flatpickr-4.6.9/LICENSE.md
+- app/assets/flatpickr-4.6.9/flatpickr.min.css
+- app/assets/flatpickr-4.6.9/flatpickr.min.js
+- app/assets/nice-select2-2.0.0/LICENSE
+- app/assets/nice-select2-2.0.0/nice-select2.min.css
+- app/assets/nice-select2-2.0.0/nice-select2.min.js
+- app/assets/spartan.svg
+- app/views/_help.html.erb
+- app/views/index.html.erb
+- app/views/scripts.js
+- app/views/styles.css
+- config.ru
+- lib/spartan_apm.rb
+- lib/spartan_apm/engine.rb
+- lib/spartan_apm/error_info.rb
+- lib/spartan_apm/instrumentation.rb
+- lib/spartan_apm/instrumentation/active_record.rb
+- lib/spartan_apm/instrumentation/base.rb
+- lib/spartan_apm/instrumentation/bunny.rb
+- lib/spartan_apm/instrumentation/cassandra.rb
+- lib/spartan_apm/instrumentation/curb.rb
+- lib/spartan_apm/instrumentation/dalli.rb
+- lib/spartan_apm/instrumentation/elasticsearch.rb
+- lib/spartan_apm/instrumentation/excon.rb
+- lib/spartan_apm/instrumentation/http.rb
+- lib/spartan_apm/instrumentation/httpclient.rb
+- lib/spartan_apm/instrumentation/net_http.rb
+- lib/spartan_apm/instrumentation/redis.rb
+- lib/spartan_apm/instrumentation/typhoeus.rb
+- lib/spartan_apm/measure.rb
+- lib/spartan_apm/metric.rb
+- lib/spartan_apm/middleware.rb
+- lib/spartan_apm/middleware/rack/end_middleware.rb
+- lib/spartan_apm/middleware/rack/start_middleware.rb
+- lib/spartan_apm/middleware/sidekiq/end_middleware.rb
+- lib/spartan_apm/middleware/sidekiq/start_middleware.rb
+- lib/spartan_apm/persistence.rb
+- lib/spartan_apm/report.rb
+- lib/spartan_apm/string_cache.rb
+- lib/spartan_apm/web.rb
+- lib/spartan_apm/web/api_request.rb
+- lib/spartan_apm/web/helpers.rb
+- lib/spartan_apm/web/router.rb
+- spartan_apm.gemspec
+homepage: https://github.com/bdurand/spartan_apm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Simple redis backed application performance monitoring tool.
+test_files: []