Services should carry the same namespace

To ensure that there are no conflicts when loading classes, lets
namespace them the same across the gem.

Author: bjonord

lib/services/auto_scaling_metrics.rb

@@ -1,5 +1,7 @@
 require_relative "auto_scaling_metrics/reporter"
 require_relative "auto_scaling_metrics/sidekiq_reporter"
 
-module AutoScalingMetrics
+module RequestQueueTime
+  module AutoScalingMetrics
+  end
 end

lib/services/auto_scaling_metrics/reporter.rb

@@ -6,105 +6,107 @@
 require "aws-sdk-cloudwatch"
 require "singleton"
 
-module AutoScalingMetrics
-  class Reporter
-    include Singleton
+module RequestQueueTime
+  module AutoScalingMetrics
+    class Reporter
+      include Singleton
 
-    DIMENSIONS = [
-      {name: "service", value: ENV["APP_NAME"]},
-      {name: "environment", value: ENV["SERVER_ENVIRONMENT"]}
-    ]
+      DIMENSIONS = [
+        {name: "service", value: ENV["APP_NAME"]},
+        {name: "environment", value: ENV["SERVER_ENVIRONMENT"]}
+      ]
 
-    attr_accessor :collector
+      attr_accessor :collector
 
-    def self.start(&)
-      return false if instance.started?
+      def self.start(&)
+        return false if instance.started?
 
-      instance.start!(&)
-    end
-
-    def self.stop
-      return unless instance.started?
-      instance.stop!
-    end
-
-    def start!(&block)
-      Rails.logger.info "Starting AutoScalingMetrics::Reporter"
-      @interval = 30
-      @buffer = Queue.new
-      @buffer_size_limit = 1000
-      @cloudwatch = Aws::CloudWatch::Client.new
-      @last_flush_time = Time.now
-      @pid = Process.pid
+        instance.start!(&)
+      end
 
-      yield self if block
+      def self.stop
+        return unless instance.started?
+        instance.stop!
+      end
 
-      start_flush_thread
-    end
+      def start!(&block)
+        Rails.logger.info "Starting AutoScalingMetrics::Reporter"
+        @interval = 30
+        @buffer = Queue.new
+        @buffer_size_limit = 1000
+        @cloudwatch = Aws::CloudWatch::Client.new
+        @last_flush_time = Time.now
+        @pid = Process.pid
 
-    def started?
-      @pid == Process.pid
-    end
+        yield self if block
 
-    def stop!
-      @_thread&.terminate
-      @_thread = nil
-      @pid = nil
-    end
+        start_flush_thread
+      end
 
-    def track_request_queue_time(time)
-      add_metric(metric_name: "request_queue_time", value: time, unit: "Milliseconds", timestamp: Time.now)
-    end
+      def started?
+        @pid == Process.pid
+      end
 
-    def self.add_metric(metric)
-      instance.add_metric(metric)
-    end
+      def stop!
+        @_thread&.terminate
+        @_thread = nil
+        @pid = nil
+      end
 
-    def add_metric(metric)
-      metric[:dimensions] = (metric[:dimensions] || []) + DIMENSIONS
-      @buffer << metric
-    end
+      def track_request_queue_time(time)
+        add_metric(metric_name: "request_queue_time", value: time, unit: "Milliseconds", timestamp: Time.now)
+      end
 
-    private
+      def self.add_metric(metric)
+        instance.add_metric(metric)
+      end
 
-    def start_flush_thread
-      @_thread = Thread.new do
-        Thread.current.name = "auto_scaling_metrics.#{@pid}"
+      def add_metric(metric)
+        metric[:dimensions] = (metric[:dimensions] || []) + DIMENSIONS
+        @buffer << metric
+      end
 
-        loop do
-          if should_flush?
-            collector&.call
-            flush_metrics
+      private
+
+      def start_flush_thread
+        @_thread = Thread.new do
+          Thread.current.name = "auto_scaling_metrics.#{@pid}"
+
+          loop do
+            if should_flush?
+              collector&.call
+              flush_metrics
+            end
+          rescue => ex
+            Sentry.capture_exception(ex)
+          ensure
+            sleep(1)
           end
-        rescue => ex
-          Sentry.capture_exception(ex)
-        ensure
-          sleep(1)
         end
       end
-    end
 
-    def should_flush?
-      @buffer.size >= @buffer_size_limit || (Time.now - @last_flush_time) >= @interval
-    end
+      def should_flush?
+        @buffer.size >= @buffer_size_limit || (Time.now - @last_flush_time) >= @interval
+      end
 
-    def flush_metrics
-      metrics_to_flush = []
-      metrics_to_flush << @buffer.pop until @buffer.empty?
+      def flush_metrics
+        metrics_to_flush = []
+        metrics_to_flush << @buffer.pop until @buffer.empty?
 
-      unless metrics_to_flush.empty?
-        put_metrics_to_cloudwatch(metrics_to_flush)
-        @last_flush_time = Time.now
+        unless metrics_to_flush.empty?
+          put_metrics_to_cloudwatch(metrics_to_flush)
+          @last_flush_time = Time.now
+        end
       end
-    end
 
-    def put_metrics_to_cloudwatch(metrics)
-      return if Rails.env.development?
+      def put_metrics_to_cloudwatch(metrics)
+        return if Rails.env.development?
 
-      @cloudwatch.put_metric_data(
-        namespace: "Teamtailor/queue_times",
-        metric_data: metrics.take(1000)
-      )
+        @cloudwatch.put_metric_data(
+          namespace: "Teamtailor/queue_times",
+          metric_data: metrics.take(1000)
+        )
+      end
     end
   end
 end

lib/services/auto_scaling_metrics/sidekiq_reporter.rb

@@ -1,23 +1,25 @@
-module AutoScalingMetrics
-  class SidekiqReporter
-    def self.enable
-      Sidekiq.configure_server do |config|
-        config.on(:leader) do
-          AutoScalingMetrics::Reporter.start do |reporter|
-            reporter.collector = method(:collect_metrics)
+module RequestQueueTime
+  module AutoScalingMetrics
+    class SidekiqReporter
+      def self.enable
+        Sidekiq.configure_server do |config|
+          config.on(:leader) do
+            AutoScalingMetrics::Reporter.start do |reporter|
+              reporter.collector = method(:collect_metrics)
+            end
           end
         end
       end
-    end
 
-    def self.collect_metrics
-      Sidekiq::Queue.all.each do |queue|
-        AutoScalingMetrics::Reporter.add_metric(
-          metric_name: "sidekiq_queue_latency",
-          value: queue.latency,
-          unit: "Seconds",
-          dimensions: [{name: "queue_name", value: queue.name}]
-        )
+      def self.collect_metrics
+        Sidekiq::Queue.all.each do |queue|
+          AutoScalingMetrics::Reporter.add_metric(
+            metric_name: "sidekiq_queue_latency",
+            value: queue.latency,
+            unit: "Seconds",
+            dimensions: [{name: "queue_name", value: queue.name}]
+          )
+        end
       end
     end
   end

spec/services/reporter_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe AutoScalingMetrics::Reporter do
+RSpec.describe RequestQueueTime::AutoScalingMetrics::Reporter do
   let(:subject) { described_class.instance }
 
   before do

spec/services/sidekiq_reporter_spec.rb

@@ -2,12 +2,12 @@
 
 require "spec_helper"
 
-RSpec.describe AutoScalingMetrics::SidekiqReporter do
+RSpec.describe RequestQueueTime::AutoScalingMetrics::SidekiqReporter do
   describe ".enable" do
     it "starts the reporter and collects metrics" do
       expect(Sidekiq).to receive(:configure_server).and_yield(config = double)
       expect(config).to receive(:on).with(:leader).and_yield
-      expect(AutoScalingMetrics::Reporter).to receive(:start).and_yield(reporter = double)
+      expect(RequestQueueTime::AutoScalingMetrics::Reporter).to receive(:start).and_yield(reporter = double)
       expect(reporter).to receive(:collector=).with(described_class.method(:collect_metrics))
 
       described_class.enable
@@ -20,13 +20,13 @@
       queue2 = double(name: "queue2", latency: 20)
       allow(Sidekiq::Queue).to receive(:all).and_return([queue1, queue2])
 
-      expect(AutoScalingMetrics::Reporter).to receive(:add_metric).with(
+      expect(RequestQueueTime::AutoScalingMetrics::Reporter).to receive(:add_metric).with(
         metric_name: "sidekiq_queue_latency",
         value: 10,
         unit: "Seconds",
         dimensions: [{name: "queue_name", value: "queue1"}]
       )
-      expect(AutoScalingMetrics::Reporter).to receive(:add_metric).with(
+      expect(RequestQueueTime::AutoScalingMetrics::Reporter).to receive(:add_metric).with(
         metric_name: "sidekiq_queue_latency",
         value: 20,
         unit: "Seconds",