neeto-monitor-ruby 1.0.42

data/lib/neeto_monitor_ruby/monitor_utils.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module NeetoMonitorRuby
+  module MonitorUtils
+    MONITOR_TYPES = {
+      check: "check",
+      job: "job",
+      heartbeat: "heartbeat"
+    }.freeze
+
+    JOB_STATES = {
+      run: "run",
+      complete: "complete",
+      fail: "fail"
+    }.freeze
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def job(monitor_key, &block)
+        monitor = Monitor.new(monitor_key)
+        series = monitor.generate_stamp
+        monitor.job_ping(state: JOB_STATES[:run], series:)
+
+        block.call
+        monitor.job_ping(state: JOB_STATES[:complete], series:)
+      rescue StandardError => exception
+        monitor.job_ping(state: JOB_STATES[:fail], message: exception.message, series:)
+        raise exception
+      end
+    end
+
+    def generate_stamp
+      Time.now.utc.to_f
+    end
+
+    def generate_series
+      "#{generate_stamp}-#{random_string}"
+    end
+
+    def random_string
+      rand(2**256).to_s(36)[0..7]
+    end
+  end
+end

data/lib/neeto_monitor_ruby/neeto_monitor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "configuration"
+require_relative "plugin"
+
+module NeetoMonitorRuby
+  extend Forwardable
+  extend self
+
+  attr_accessor :config, :logger
+
+  def_delegator "NeetoMonitorRuby::Monitor", :load_monitors!
+
+  def init!(options = {})
+    self.config = Configuration.configure!(options, true)
+    self.logger = self.config.logger
+  end
+
+  def load_plugins!
+    Dir[File.expand_path("../plugins/*.rb", __FILE__)].each do |plugin|
+      require plugin
+    end
+    Plugin.load!(self.config)
+  end
+end
+
+NeetoMonitor = NeetoMonitorRuby

data/lib/neeto_monitor_ruby/plugin.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module NeetoMonitorRuby
+  class Plugin
+    class << self
+      @@instances = {}
+
+      def instances
+        @@instances
+      end
+
+      def register(name = nil, &block)
+        raise(ArgumentError, "Plugin name is required, but was nil.") unless name
+
+        key = name.to_sym
+        raise("Already registered: #{name}") if instances[key]
+
+        instances[key] = new(name).tap { |d| d.instance_eval(&block) }
+      end
+
+      def load!(config)
+        instances.each_pair do |name, plugin|
+          if config.public_send("#{name}_enabled")
+            plugin.load!
+          else
+            NeetoMonitorRuby.logger.debug("skipped plugin #{name} load because it's disabled")
+          end
+        end
+      end
+    end
+
+    attr_reader :name, :requirements, :executions, :config
+
+    def initialize(name)
+      @name = name
+      @loaded = false
+      @requirements = []
+      @executions = []
+    end
+
+    def requirement(&block)
+      @requirements << block
+    end
+
+    def execution(&block)
+      @executions << block
+    end
+
+    def load!
+      if loaded?
+        NeetoMonitorRuby.logger.debug("skip plugin #{name} as already loaded")
+        return false
+      elsif fulfilled?
+        NeetoMonitorRuby.logger.debug("load plugin #{name}")
+        @executions.each { |block| instance_eval(&block) }
+        @loaded = true
+      else
+        NeetoMonitorRuby.logger.debug("skip plugin load #{name} requirement not fulfilled")
+      end
+
+      @loaded
+    rescue => exception
+      log_plugin_exception(exception)
+      @loaded = true
+      false
+    end
+
+    def fulfilled?
+      @requirements.all? { |block| instance_eval(&block) }
+    rescue => exception
+      log_plugin_exception(exception)
+      false
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    private
+
+      def log_plugin_exception(exception)
+        NeetoMonitorRuby.logger.error("plugin error name=#{name} class=#{exception.class} #{exception.message}")
+        NeetoMonitorRuby.logger.error e.backtrace
+      end
+  end
+end

data/lib/neeto_monitor_ruby/plugins/sidekiq.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../monitor_utils"
+
+module NeetoMonitorRuby
+  module Plugins
+    module Sidekiq
+      class ServerMiddleware
+        SKIPPED_WORKERS = %w(ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper).freeze
+
+        attr_reader :sidekiq_worker
+
+        def call(worker, _message, _queue)
+          @sidekiq_worker = worker
+
+          job_ping(state: MonitorUtils::JOB_STATES[:run])
+
+          worker_result = yield
+
+          job_ping(state: MonitorUtils::JOB_STATES[:complete])
+
+          worker_result
+        rescue => exception
+          job_ping(state: MonitorUtils::JOB_STATES[:fail], message: exception.message)
+
+          raise exception
+        end
+
+        private
+
+          def job_ping(state:, message: nil)
+            return unless can_monitor?
+
+            ::Sidekiq.logger.debug("neetoMonitor pinging key: #{monitor_key} state: #{state} message: #{message}")
+
+            neeto_monitor.job_ping(state:, message:, series:)
+
+          rescue => exception
+            ::Sidekiq.logger.error("Error: neetoMonitor ping #{monitor_key} - #{exception.message}")
+            ::Sidekiq.logger.error(exception.backtrace)
+          end
+
+          def series
+            @_series ||= neeto_monitor.generate_series
+          end
+
+          def neeto_monitor
+            @_neeto_monitor ||= NeetoMonitorRuby::Monitor.new(monitor_key)
+          end
+
+          def monitor_key
+            return @_monitor_key if @_monitor_key
+
+            @_monitor_key = fetch_sidekiq_option("neeto_monitor_key", sidekiq_worker.class.name)
+            return @_monitor_key unless NeetoMonitorRuby.config.key_prefix_enabled && NeetoMonitorRuby.config.key_prefix
+
+            @_monitor_key = [NeetoMonitorRuby.config.key_prefix, @_monitor_key].join("::")
+          end
+
+          def neeto_monitor_disabled?
+            fetch_sidekiq_option("neeto_monitor_disabled", false)
+          end
+
+          def fetch_sidekiq_option(key, default = nil)
+            sidekiq_worker.class.sidekiq_options.fetch(key, default)
+          end
+
+          def can_monitor?
+            @_can_monitor ||= !neeto_monitor.api_key.nil? && !neeto_monitor_disabled? && !skip?
+          end
+
+          def skip?
+            SKIPPED_WORKERS.include?(monitor_key) || SKIPPED_WORKERS.include?(monitor_key.split("::", 2).last)
+          end
+      end
+
+      Plugin.register "sidekiq" do
+        requirement { defined?(::Sidekiq) }
+
+        execution do
+          ::Sidekiq.configure_server do |sidekiq|
+            sidekiq.server_middleware do |chain|
+              chain.prepend ServerMiddleware
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neeto_monitor_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NeetoMonitorRuby
+  VERSION = "1.0.42".freeze
+end

data/test/dummy/failure_worker.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Dummy
+  class FailureWorker
+    include Sidekiq::Worker
+    sidekiq_options neeto_monitor_key: "failure_worker"
+
+    def perform
+      raise StandardError
+    end
+  end
+end

data/test/dummy/monitor_disabled_worker.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Dummy
+  class MonitorDisabledWorker
+    include Sidekiq::Worker
+    sidekiq_options neeto_monitor_disabled: true
+
+    def perform
+      true
+    end
+  end
+end

data/test/dummy/success_worker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Dummy
+  class SuccessWorker
+    include Sidekiq::Worker
+
+    def perform
+      true
+    end
+  end
+end

data/test/neeto_monitor/configuration_test.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module NeetoMonitor
+  class ConfigurationTest < Minitest::Test
+    attr_reader :yaml_file_path
+
+    def setup
+      @yaml_file_path = "./test/config.yml"
+      NeetoMonitor::Configuration.reset!
+    end
+
+    def test_configure_with_options
+      config = NeetoMonitor::Configuration.configure!({ api_key: "api_key", environment: "test" }, true)
+
+      assert_equal "api_key", config.api_key
+      assert_equal "test", config.environment
+    end
+
+    def test_configure_with_default_values
+      config = NeetoMonitor::Configuration.configure!
+
+      assert_equal NeetoMonitor::Configuration::BASE_URL, config.base_url
+      assert_equal NeetoMonitor::Configuration::DEFAULT_PING_TIMEOUT, config.ping_timeout
+      assert_equal true, config.sidekiq_enabled
+      assert_nil config.config_path
+    end
+
+    def test_load_config_with_valid_file
+      config_file = File.new(yaml_file_path, "w")
+      config_file.write(YAML.dump(api_key: "dgs56sds7d", environment: "test"))
+      config_file.close
+
+      config = NeetoMonitor::Configuration.configure!({ config_path: config_file.path }, true)
+
+      assert_equal "dgs56sds7d", config.api_key
+      assert_equal "test", config.environment
+      assert_equal "https://neetomonitor.com", config.base_url
+
+      File.delete(yaml_file_path)
+    end
+
+    def test_load_config_with_invalid_file
+      config_file = File.new(yaml_file_path, "w")
+      config_file.write("api_key kbkj'api_key'\" \n}environment: 'test'")
+      config_file.close
+
+      assert_raises NeetoMonitor::ConfigurationError do
+        NeetoMonitor::Configuration.load_config(config_file.path)
+      end
+
+      File.delete(yaml_file_path)
+    end
+
+    def test_reset
+      config = NeetoMonitor::Configuration.configure!({ api_key: "api_key", config_path: "no-config.yml" }, true)
+
+      assert_equal "https://neetomonitor.com", config.base_url
+
+      NeetoMonitor::Configuration.reset!
+
+      assert_equal "3d6d07b40ac6", NeetoMonitor::Configuration.config.api_key
+      assert_nil NeetoMonitor::Configuration.config.config_path
+    end
+
+    def test_load_config_with_file_not_found
+      assert_raises NeetoMonitor::ConfigurationError do
+        NeetoMonitor::Configuration.load_config("./test/not_found.yml")
+      end
+    end
+
+    def test_fetch_or_set_value_with_environment_variable
+      original_value = ENV["NEETO_MONITOR_API_KEY"]
+      ENV["NEETO_MONITOR_API_KEY"] = "env_api_key"
+
+      config = NeetoMonitor::Configuration.new
+
+      assert_equal "env_api_key", config.api_key
+
+      ENV["NEETO_MONITOR_API_KEY"] = original_value
+    end
+
+    def test_fetch_or_set_value_with_options
+      config = NeetoMonitor::Configuration.new(api_key: "options_api_key")
+
+      assert_equal "options_api_key", config.api_key
+    end
+
+    def test_fetch_or_set_value_with_default_value
+      config = NeetoMonitor::Configuration.new
+
+      assert_equal 8, config.ping_timeout
+      assert_equal true, config.sidekiq_enabled
+    end
+  end
+end

data/test/neeto_monitor/heartbeat_runner_job_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NeetoMonitor::HeartbeatRunnerJobTest < ActiveJob::TestCase
+  def test_job_pings_heartbeat_and_enqueues_another_job
+    heartbeat_name = "neeto-heartbeat"
+    schedule = "* * * * *"
+    stub_ping_request
+
+    NeetoMonitorRuby::HeartbeatRunnerJob.perform_now(heartbeat_name, schedule)
+
+    assert_enqueued_with(
+      job: NeetoMonitorRuby::HeartbeatRunnerJob,
+      args: [heartbeat_name, schedule],
+      at: ->(t) { t > Time.now }
+    ) do
+      NeetoMonitorRuby::HeartbeatRunnerJob.perform_now(heartbeat_name, schedule)
+    end
+  end
+
+  private
+
+    def stub_ping_request(monitor_key = "neeto-heartbeat", params = {}, status_code = 200)
+      stub_request(:get, "https://neetomonitor.com/tm/3d6d07b40ac6/#{monitor_key}")
+        .with(
+          query: hash_including({ "env" => "test" }.merge(params)),
+          headers: {
+            "Accept" => "application/json",
+            "Content-Type" => "application/json",
+            "User-Agent" => "neeto-monitor-ruby"
+          }
+        )
+        .to_return(status: status_code, body: "", headers: {})
+    end
+end

data/test/neeto_monitor/monitor_test.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class NeetoMonitor::MonitorTest < Minitest::Test
+  include ActiveJob::TestHelper
+
+  def test_monitor_sends_telemetry_event
+    stub_ping_request
+    monitor = NeetoMonitor::Monitor.new("website-check")
+
+    assert monitor.ping
+  end
+
+  def test_monitor_sends_telemetry_event_with_params
+    params = { state: "run", series: "job101" }
+    job_monitor_key = "night-job-check"
+
+    stub_ping_request(job_monitor_key, params)
+    monitor = NeetoMonitor::Monitor.new(job_monitor_key)
+
+    assert monitor.ping(params)
+  end
+
+  def test_monitor_job_sends_complete_event
+    job_monitor_key = "night-job-check"
+
+    stub_ping_request(job_monitor_key, { state: "run", kind: "job" })
+    stub_ping_request(job_monitor_key, { state: "complete", kind: "job" })
+
+    response = NeetoMonitor::Monitor.job job_monitor_key do
+      perform_addition_work(100, 200)
+    end
+
+    assert response
+  end
+
+  def test_monitor_job_sends_fail_event
+    job_monitor_key = "night-job-check"
+
+    stub_ping_request(job_monitor_key, { state: "run", kind: "job" })
+    stub_ping_request(job_monitor_key, { state: "fail", kind: "job" })
+
+    assert_raises(StandardError) do
+      NeetoMonitor::Monitor.job job_monitor_key { raise StandardError.new }
+    end
+  end
+
+  def test_load_monitors!
+    yaml_file_path = "./test/config.yml"
+    reset = true
+    stub_bulk_create_request
+    stub_ping_request("neeto-heartbeat")
+
+    assert_no_enqueued_jobs
+
+    NeetoMonitorRuby::HeartbeatRunnerJob.perform_later("neeto-heartbeat", "* * * * *")
+
+    assert_enqueued_jobs 1
+
+    config_file = File.new(yaml_file_path, "w")
+    config_file.write(YAML.dump(config_hash))
+    config_file.close
+
+    NeetoMonitor.init!({ config_path: config_file.path })
+    NeetoMonitor::Monitor.load_monitors!
+
+    assert_enqueued_jobs 1
+
+    NeetoMonitor.init!
+    File.delete(yaml_file_path)
+  end
+
+  private
+
+    def stub_ping_request(monitor_key = "website-check", params = {}, status_code = 200)
+      stub_request(:get, "https://neetomonitor.com/tm/3d6d07b40ac6/#{monitor_key}")
+        .with(
+          query: hash_including({ "env" => "test" }.merge(params)),
+          headers: {
+            "Accept" => "application/json",
+            "Content-Type" => "application/json",
+            "User-Agent" => "neeto-monitor-ruby"
+          }
+        )
+        .to_return(status: status_code, body: "", headers: {})
+    end
+
+    def perform_addition_work(param1, param2)
+      param1 + param2
+    end
+
+    def stub_bulk_create_request
+      stub_request(:post, "https://neetomonitor.com/api/v1/clients/bulk_checks")
+        .with(
+          body: bulk_create_params.to_json,
+          headers: {
+            "Accept" => "application/json",
+            "Content-Type" => "application/json",
+            "User-Agent" => "neeto-monitor-ruby"
+          }
+        )
+        .to_return(status: 200, body: "", headers: {})
+    end
+
+    def config_hash
+      {
+        api_key: "3d6d07b40ac6",
+        environment: "test",
+        monitors: {
+          jobs: [
+            {
+              name: "neeto-job",
+              schedule: "0 0 * * *"
+            }
+          ],
+          checks: [
+            {
+              name: "neeto-monitor",
+              request_attributes: {
+                endpoint: "http://app.neetomonitor.test/health_check/",
+                kind: "http",
+                verb: "get",
+                interval: 10,
+                timeout: 20
+              }
+            }
+          ],
+          heartbeats: [
+            {
+              name: "neeto-heartbeat",
+              schedule: "* * * * *"
+            }
+          ]
+        }
+      }
+    end
+
+    def bulk_create_params
+      {
+        checks: [
+          {
+            name: "neeto-job",
+            schedule: "0 0 * * *",
+            kind: "job",
+            environment: "test"
+          },
+          {
+            name: "neeto-monitor",
+            request_attributes: {
+              endpoint: "http://app.neetomonitor.test/health_check/",
+              kind: "http",
+              verb: "get",
+              interval: 10,
+              timeout: 20
+            },
+            kind: "check",
+            environment: "test"
+          }
+        ],
+        api_key: "3d6d07b40ac6"
+      }
+    end
+end

data/test/neeto_monitor/neeto_monitor_test.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class NeetoMonitorTest < Minitest::Test
+  def test_init!
+    assert_instance_of Logger, NeetoMonitor.logger
+    assert_instance_of NeetoMonitor::Configuration, NeetoMonitor.config
+  end
+end

data/test/neeto_monitor/plugin_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module NeetoMonitor
+  class PluginTest < Minitest::Test
+    attr_reader :config
+
+    def setup
+      NeetoMonitor::Plugin.instances.clear
+      @config = Configuration.new({ sidekiq_enabled: true })
+    end
+
+    def test_register
+      NeetoMonitor::Plugin.register("sidekiq", &requirement_block)
+      instances = NeetoMonitor::Plugin.instances
+
+      assert_equal 1, instances.size
+      assert_equal "sidekiq", instances[:sidekiq].name
+      assert_instance_of NeetoMonitor::Plugin, instances[:sidekiq]
+    end
+
+    def test_register_without_name
+      assert_raises(ArgumentError) { NeetoMonitor::Plugin.register }
+    end
+
+    def test_register_with_duplicate_name
+      NeetoMonitor::Plugin.register("sidekiq", &requirement_block)
+
+      assert_raises(RuntimeError) { NeetoMonitor::Plugin.register("sidekiq", &requirement_block) }
+    end
+
+    def test_load_enabled_plugins
+      @@executed = false
+
+      NeetoMonitor::Plugin.register("sidekiq") do
+        requirement { true }
+        execution { @@executed = true }
+      end
+
+      NeetoMonitor::Plugin.load!(config)
+
+      sidekiq_instance = NeetoMonitor::Plugin.instances[:sidekiq]
+
+      assert sidekiq_instance.loaded?
+      assert @@executed
+    end
+
+    def test_skip_disabled_plugins
+      NeetoMonitor::Plugin.register("sidekiq", &requirement_block)
+
+      new_config = Configuration.new({ sidekiq_enabled: false })
+      NeetoMonitor::Plugin.load!(new_config)
+
+      instances = NeetoMonitor::Plugin.instances
+      refute instances[:sidekiq].loaded?
+    end
+
+    def test_skip_plugins_with_unfulfilled_requirements
+      NeetoMonitor::Plugin.register("sidekiq", &requirement_unfulfilled_block)
+
+      NeetoMonitor::Plugin.load!(config)
+
+      instances = NeetoMonitor::Plugin.instances
+      refute instances[:sidekiq].loaded?
+    end
+
+    private
+
+      def requirement_block
+        proc { requirement { true } }
+      end
+
+      def requirement_unfulfilled_block
+        proc { requirement { false } }
+      end
+  end
+end