service_skeleton 0.0.0.1.ENOTAG → 0.0.0.2.g46c1e0e

data/lib/service_skeleton/background_worker.rb

@@ -0,0 +1,80 @@
+class ServiceSkeleton
+  module BackgroundWorker
+    include ServiceSkeleton::LoggingHelpers
+
+    # async code is a shit to test, and rarely finds bugs anyway, so let's
+    # just
+    #:nocov:
+    # this whole thing.
+
+    # This signal is raised internally if needed to shut down a worker thread.
+    class TerminateBackgroundThread < Exception; end
+    private_constant :TerminateBackgroundThread
+
+    def initialize(*_)
+      @bg_worker_op_mutex = Mutex.new
+      @bg_worker_op_cv    = ConditionVariable.new
+
+      begin
+        super
+      rescue ArgumentError => ex
+        if ex.message =~ /wrong number of arguments.*expected 0/
+          super()
+        else
+          raise
+        end
+      end
+    end
+
+    def start!
+      @bg_worker_op_mutex.synchronize do
+        return if @bg_worker_thread
+
+        @bg_worker_thread = Thread.new do
+          Thread.current.name = self.class.to_s
+
+          Thread.handle_interrupt(Exception => :never) do
+            logger.debug("BackgroundWorker(#{self.class})#start!") { "Background worker thread #{Thread.current.object_id} starting" }
+            begin
+              Thread.handle_interrupt(Exception => :immediate) do
+                @bg_worker_op_mutex.synchronize { @bg_worker_op_cv.signal }
+                self.start
+              end
+            rescue TerminateBackgroundThread
+              logger.debug("BackgroundWorker(#{self.class})#start!") { "Background worker thread #{Thread.current.object_id} received magical termination exception" }
+            rescue Exception => ex
+              log_exception(ex) { "Background worker thread #{Thread.current.object_id} received fatal exception" }
+            else
+              logger.debug("BackgroundWorker(#{self.class})#start!") { "Background worker thread #{Thread.current.object_id} terminating" }
+            end
+          end
+        end
+
+        @bg_worker_op_cv.wait(@bg_worker_op_mutex) until @bg_worker_thread
+      end
+    end
+
+    def stop!
+      @bg_worker_op_mutex.synchronize do
+        return if @bg_worker_thread.nil?
+
+        logger.debug("BackgroundWorker(#{self.class})#stop!") { "Terminating worker thread #{Thread.current.object_id} as requested" }
+
+        shutdown
+
+        @bg_worker_thread.join
+        @bg_worker_thread = nil
+
+        logger.debug("BackgroundWorker(#{self.class})#stop!") { "Worker thread terminated" }
+      end
+    end
+
+    private
+
+    attr_reader :logger
+
+    def shutdown
+      @bg_worker_thread.raise(TerminateBackgroundThread)
+    end
+  end
+end

data/lib/service_skeleton/config.rb

@@ -1,58 +1,38 @@
-# frozen_string_literal: true
-
 require "to_regexp"
 
 require_relative "./filtering_logger"
 
-require "loggerstash"
-
-module ServiceSkeleton
+class ServiceSkeleton
   class Config
-    attr_reader :logger, :pre_run_logger, :env, :service_name
-
-    def initialize(env, service_name, variables)
-      @service_name = service_name
-
-      # Parsing variables will redact the environment, so we want to take a
-      # private unredacted copy before that happens for #[] lookup in the
-      # future.
-      @env = env.to_hash.dup.freeze
+    attr_reader :logger
 
-      parse_variables(internal_variables + variables, env)
+    def initialize(env, svc)
+      @env = env.to_hash.freeze
+      @svc = svc
 
-      # Sadly, we can't setup the logger until we know *how* to setup the
-      # logger, which requires parsing config variables
+      parse_registered_variables(env)
       setup_logger
     end
 
     def [](k)
-      @env[k].dup
+      @env[k]
     end
 
     private
 
-    def parse_variables(variables, env)
-      variables.map do |var|
-        var[:class].new(var[:name], env, **var[:opts])
-      end.each do |var|
-        val = var.value
-        method_name = var.method_name(@service_name).to_sym
-
-        define_singleton_method(method_name) do
+    def parse_registered_variables(env)
+      @svc.registered_variables.each do |var|
+        val = var.value(env[var.name.to_s])
+        define_singleton_method(var.method_name(@svc.service_name)) do
           val
         end
 
-        define_singleton_method(:"#{method_name}=") do |new_value|
-          val = new_value
-        end
-      end.each do |var|
-        if var.redact?(env)
+        if var.sensitive?
           if env.object_id != ENV.object_id
             raise ServiceSkeleton::Error::CannotSanitizeEnvironmentError,
-                  "Attempted to sanitize sensitive variable #{var.name}, but we're not operating on the process' environment"
-          else
-            var.redact!(env)
+                  "Attempted to sanitize sensitive variable #{var.name}, but was not passed the ENV object"
           end
+          env.delete(var.name.to_s)
         end
       end
     end
@@ -66,42 +46,14 @@ module ServiceSkeleton
 
       @logger = Logger.new(log_file || $stderr, shift_age, shift_size)
 
-      # Can be used prior to a call to ultravisor#run. This prevents a race condition
-      # when a logstash server is configured but the logstash writer is not yet
-      # initialised. This should never be updated after it is configured.
-      @pre_run_logger = Logger.new(log_file || $stderr, shift_age, shift_size)
-
-      if Thread.main
-        Thread.main[:thread_map_number] = 0
+      if log_enable_timestamps
+        @logger.formatter = ->(s, t, p, m) { "#{t.utc.strftime("%FT%T.%NZ")} #{s[0]} [#{p}] #{m}\n" }
       else
-        #:nocov:
-        Thread.current[:thread_map_number] = 0
-        #:nocov:
-      end
-
-      thread_map_mutex = Mutex.new
-
-      [@logger, @pre_run_logger].each do |logger|
-        logger.formatter = ->(s, t, p, m) do
-          th_n = if Thread.current.name
-            #:nocov:
-            Thread.current.name
-            #:nocov:
-          else
-            thread_map_mutex.synchronize do
-              Thread.current[:thread_map_number] ||= begin
-                Thread.list.select { |th| th[:thread_map_number] }.length
-              end
-            end
-          end
-
-          ts = log_enable_timestamps ? "#{t.utc.strftime("%FT%T.%NZ")} " : ""
-          "#{ts}#{$$}##{th_n} #{s[0]} [#{p}] #{m}\n"
-        end
+        @logger.formatter = ->(s, t, p, m) { "#{s[0]} [#{p}] #{m}\n" }
       end
 
       @logger.filters = []
-      @env.fetch("#{@service_name.upcase}_LOG_LEVEL", "INFO").split(/\s*,\s*/).each do |spec|
+      @env.fetch("#{@svc.service_name.upcase}_LOG_LEVEL", "INFO").split(/\s*,\s*/).each do |spec|
         if spec.index("=")
           # "Your developers were so preoccupied with whether or not they
           # could, they didn't stop to think if they should."
@@ -124,17 +76,5 @@ module ServiceSkeleton
         end
       end
     end
-
-    def internal_variables
-      [
-        { name: "#{@service_name.upcase}_LOG_LEVEL",             class: ConfigVariable::String,  opts: { default: "INFO" } },
-        { name: "#{@service_name.upcase}_LOG_ENABLE_TIMESTAMPS", class: ConfigVariable::Boolean, opts: { default: false } },
-        { name: "#{@service_name.upcase}_LOG_FILE",              class: ConfigVariable::String,  opts: { default: nil } },
-        { name: "#{@service_name.upcase}_LOG_MAX_FILE_SIZE",     class: ConfigVariable::Integer, opts: { default: 1048576, range: 0..Float::INFINITY } },
-        { name: "#{@service_name.upcase}_LOG_MAX_FILES",         class: ConfigVariable::Integer, opts: { default: 3,       range: 1..Float::INFINITY } },
-        { name: "#{@service_name.upcase}_LOGSTASH_SERVER",       class: ConfigVariable::String,  opts: { default: "" } },
-        { name: "#{@service_name.upcase}_METRICS_PORT",          class: ConfigVariable::Integer, opts: { default: nil,     range: 1..65535 } },
-      ]
-    end
   end
 end

data/lib/service_skeleton/config_variable.rb

@@ -1,44 +1,23 @@
-# frozen_string_literal: true
-
-module ServiceSkeleton
+class ServiceSkeleton
   class ConfigVariable
-    attr_reader :name, :value
+    attr_reader :name
 
-    def initialize(name, env, **opts, &blk)
+    def initialize(name, **opts, &blk)
       @name = name
       @opts = opts
       @blk  = blk
-
-      @value = pluck_value(env)
     end
 
     def method_name(svc_name)
-      @name.to_s.gsub(/\A#{Regexp.quote(svc_name)}_/i, '').downcase
+      name.to_s.gsub(/\A#{Regexp.quote(svc_name)}_/i, '').downcase
     end
 
-    def redact?(env)
-      @opts[:sensitive]
+    def sensitive?
+      !!@opts[:sensitive]
     end
 
-    def redact!(env)
-      if @opts[:sensitive]
-        env[@name.to_s] = "*SENSITIVE*" if env.has_key?(@name.to_s)
-      end
-    end
-
-    private
-
-    def maybe_default(env)
-      if env.has_key?(@name.to_s)
-        yield
-      else
-        if @opts.has_key?(:default)
-          @opts[:default]
-        else
-          raise ServiceSkeleton::Error::InvalidEnvironmentError,
-                "Value for required environment variable #{@name} not specified"
-        end
-      end
+    def value(raw_val)
+      @blk.call(raw_val)
     end
   end
 end

data/lib/service_skeleton/config_variables.rb

@@ -1,79 +1,93 @@
-# frozen_string_literal: true
-
 require_relative "./error"
 
 require "service_skeleton/config_variable"
 
-module ServiceSkeleton
+class ServiceSkeleton
   module ConfigVariables
-    UNDEFINED = Module.new
+    attr_reader :registered_variables
+
+    UNDEFINED = Class.new
     private_constant :UNDEFINED
 
-    def registered_variables
+    def register_variable(name, **opts, &callback)
       @registered_variables ||= []
+
+      @registered_variables << ServiceSkeleton::ConfigVariable.new(name, **opts, &callback)
     end
 
-    def register_variable(name, klass, **opts)
-      if opts[:default] == UNDEFINED
-        opts.delete(:default)
+    def string(var_name, default: UNDEFINED, sensitive: false)
+      register_variable(var_name, sensitive: sensitive) do |value|
+        maybe_default(value, default, var_name) do
+          value
+        end
       end
-
-      registered_variables << {
-        name: name,
-        class: klass,
-        opts: opts,
-      }
     end
 
     def boolean(var_name, default: UNDEFINED, sensitive: false)
-      register_variable(var_name, ConfigVariable::Boolean, default: default, sensitive: sensitive)
-    end
-
-    def enum(var_name, values:, default: UNDEFINED, sensitive: false)
-      unless values.is_a?(Hash) || values.is_a?(Array)
-        raise ArgumentError,
-              "values option to enum must be a hash or array"
+      register_variable(var_name, sensitive: sensitive) do |value|
+        maybe_default(value, default, var_name) do
+          case value
+          when /\A(no|n|off|0|false)\z/i
+            false
+          when /\A(yes|y|on|1|true)\z/i
+            true
+          else
+            raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                  "Value #{value.inspect} for environment variable #{var_name} is not a valid boolean value"
+          end
+        end
       end
-
-      register_variable(var_name, ConfigVariable::Enum, default: default, sensitive: sensitive, values: values)
-    end
-
-    def float(var_name, default: UNDEFINED, sensitive: false, range: -Float::INFINITY..Float::INFINITY)
-      register_variable(var_name, ConfigVariable::Float, default: default, sensitive: sensitive, range: range)
     end
 
     def integer(var_name, default: UNDEFINED, sensitive: false, range: -Float::INFINITY..Float::INFINITY)
-      register_variable(var_name, ConfigVariable::Integer, default: default, sensitive: sensitive, range: range)
-    end
-
-    def kv_list(var_name, default: UNDEFINED, sensitive: false, key_pattern: /\A#{var_name}_(.*)\z/)
-      register_variable(var_name, ConfigVariable::KVList, default: default, sensitive: sensitive, key_pattern: key_pattern)
-    end
-
-    def path_list(var_name, default: UNDEFINED, sensitive: false)
-      register_variable(var_name, ConfigVariable::PathList, default: default, sensitive: sensitive)
-    end
-
-    def string(var_name, default: UNDEFINED, sensitive: false, match: nil)
-      register_variable(var_name, ConfigVariable::String, default: default, sensitive: sensitive, match: match)
+      register_variable(var_name, sensitive: sensitive) do |value|
+        maybe_default(value, default, var_name) do
+          if value =~ /\A-?\d+\z/
+            value.to_i.tap do |i|
+              unless range.include?(i)
+                raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                  "Value #{i} for environment variable #{var_name} is out of the valid range (must be between #{range.first} and #{range.last} inclusive)"
+              end
+            end
+          else
+            raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                  "Value #{value.inspect} for environment variable #{var_name} is not a valid integer value"
+          end
+        end
+      end
     end
 
-    def url(var_name, default: UNDEFINED, sensitive: false)
-      register_variable(var_name, ConfigVariable::URL, default: default, sensitive: sensitive)
+    def float(var_name, default: UNDEFINED, sensitive: false, range: -Float::INFINITY..Float::INFINITY)
+      register_variable(var_name, sensitive: sensitive) do |value|
+        maybe_default(value, default, var_name) do
+          if value =~ /\A-?\d+.?\d*\z/
+            value.to_f.tap do |i|
+              unless range.include?(i)
+                raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                  "Value #{i} for environment variable #{var_name} is out of the valid range (must be between #{range.first} and #{range.last} inclusive)"
+              end
+            end
+          else
+            raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                  "Value #{value.inspect} for environment variable #{var_name} is not a valid numeric value"
+          end
+        end
+      end
     end
 
-    def yaml_file(var_name, default: UNDEFINED, sensitive: false, klass: nil)
-      register_variable(var_name, ConfigVariable::YamlFile, default: default, sensitive: sensitive, klass: klass)
+    private
+
+    def maybe_default(value, default, var_name)
+      if value.nil?
+        if default == UNDEFINED
+          raise ServiceSkeleton::Error::InvalidEnvironmentError,
+                "Value for required environment variable #{var_name} not specified"
+        else
+          default
+        end
+      else
+        yield
+      end
     end
   end
 end
-
-require_relative "config_variable/boolean"
-require_relative "config_variable/enum"
-require_relative "config_variable/float"
-require_relative "config_variable/integer"
-require_relative "config_variable/kv_list"
-require_relative "config_variable/path_list"
-require_relative "config_variable/string"
-require_relative "config_variable/url"
-require_relative "config_variable/yaml_file"

data/lib/service_skeleton/error.rb

@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
-module ServiceSkeleton
+class ServiceSkeleton
   class Error < StandardError
-    class CannotSanitizeEnvironmentError < Error; end
     class InvalidEnvironmentError < Error; end
+    class CannotSanitizeEnvironmentError < Error; end
+    class InheritanceContractError < Error; end
     class InvalidMetricNameError < Error; end
-    class InvalidServiceClassError < Error; end
   end
 end

data/lib/service_skeleton/filtering_logger.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'logger'
 
 module FilteringLogger

data/lib/service_skeleton/logging_helpers.rb

@@ -1,28 +1,21 @@
-# frozen_string_literal: true
-
-module ServiceSkeleton
+class ServiceSkeleton
   module LoggingHelpers
     private
 
     def log_exception(ex, progname = nil)
-      #:nocov:
       progname ||= "#{self.class.to_s}##{caller_locations(2, 1).first.label}"
 
       logger.error(progname) do
+        #:nocov:
         explanation = if block_given?
           yield
         else
           nil
         end
+        #:nocov:
 
         (["#{explanation}#{explanation ? ": " : ""}#{ex.message} (#{ex.class})"] + ex.backtrace).join("\n  ")
       end
-      #:nocov:
-    end
-
-    def logloc
-      loc = caller_locations.first
-      "#{self.class}##{loc.label}"
     end
   end
 end

data/lib/service_skeleton/metrics_methods.rb

@@ -1,37 +1,22 @@
-# frozen_string_literal: true
-
-require "prometheus/client"
-
-require_relative "metric_method_name"
-
-Prometheus::Client::Metric.include(ServiceSkeleton::MetricMethodName)
-
-module ServiceSkeleton
+class ServiceSkeleton
   module MetricsMethods
-    def registered_metrics
-      @registered_metrics || []
-    end
-
-    def metric(metric)
-      @registered_metrics ||= []
-
-      @registered_metrics << metric
+    def service=(svc)
+      @service = svc
     end
 
-    def counter(name, docstring:, labels: [], preset_labels: {})
-      metric(Prometheus::Client::Counter.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
-    end
+    def register(metric)
+      method_name = metric.name.to_s.gsub(/\A#{Regexp.quote(@service.service_name)}_/, '').to_sym
 
-    def gauge(name, docstring:, labels: [], preset_labels: {})
-      metric(Prometheus::Client::Gauge.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
-    end
+      if self.class.method_defined?(method_name)
+        raise ServiceSkeleton::Error::InvalidMetricNameError,
+              "There is already a method named #{method_name} on ##metrics, so you can't have a metric named #{metric.name}"
+      end
 
-    def summary(name, docstring:, labels: [], preset_labels: {})
-      metric(Prometheus::Client::Summary.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
-    end
+      define_singleton_method(method_name) do
+        metric
+      end
 
-    def histogram(name, docstring:, labels: [], preset_labels: {}, buckets: Prometheus::Client::Histogram::DEFAULT_BUCKETS)
-      metric(Prometheus::Client::Histogram.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels, buckets: buckets))
+      super
     end
   end
 end