service_skeleton 0.0.0.44.g75d07d7 → 1.0.3

data/lib/service_skeleton/error.rb

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

data/lib/service_skeleton/generator.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "signal_manager"
+require_relative "ultravisor_loggerstash"
+
+require "frankenstein/ruby_gc_metrics"
+require "frankenstein/ruby_vm_metrics"
+require "frankenstein/process_metrics"
+require "frankenstein/server"
+require "prometheus/client/registry"
+require "sigdump"
+require "ultravisor"
+
+module ServiceSkeleton
+  module Generator
+    def generate(config:, metrics_registry:, service_metrics:, service_signal_handlers:)
+      Ultravisor.new(logger: config.logger).tap do |ultravisor|
+        initialize_metrics(ultravisor, config, metrics_registry, service_metrics)
+        initialize_loggerstash(ultravisor, config, metrics_registry)
+        initialize_signals(ultravisor, config, service_signal_handlers, metrics_registry)
+      end
+    end
+
+    private
+
+    def initialize_metrics(ultravisor, config, registry, metrics)
+      Frankenstein::RubyGCMetrics.register(registry)
+      Frankenstein::RubyVMMetrics.register(registry)
+      Frankenstein::ProcessMetrics.register(registry)
+
+      metrics.each do |m|
+        registry.register(m)
+
+        method_name = m.method_name(config.service_name)
+
+        if registry.singleton_class.method_defined?(method_name)
+          raise ServiceSkeleton::Error::InvalidMetricNameError,
+                "Metric method #{method_name} is already defined"
+        end
+
+        registry.define_singleton_method(method_name) do
+          m
+        end
+      end
+
+      if config.metrics_port
+        config.pre_run_logger.info(config.service_name) { "Starting metrics server on port #{config.metrics_port}" }
+        ultravisor.add_child(
+          id: :metrics_server,
+          klass: Frankenstein::Server,
+          method: :run,
+          args: [
+            port: config.metrics_port,
+            logger: config.logger,
+            metrics_prefix: :"#{config.service_name}_metrics_server",
+            registry: registry,
+          ]
+        )
+      end
+    end
+
+    def initialize_loggerstash(ultravisor, config, registry)
+      if config.logstash_server && !config.logstash_server.empty?
+        config.pre_run_logger.info(config.service_name) { "Configuring loggerstash to send to #{config.logstash_server}" }
+
+        ultravisor.add_child(
+          id: :logstash_writer,
+          klass: LogstashWriter,
+          method: :run,
+          args: [
+            server_name: config.logstash_server,
+            metrics_registry: registry,
+            logger: config.logger,
+          ],
+          access: :unsafe
+        )
+
+        config.logger.singleton_class.prepend(Loggerstash::Mixin)
+
+        config.logger.instance_variable_set(:@ultravisor, ultravisor)
+        config.logger.singleton_class.prepend(ServiceSkeleton::UltravisorLoggerstash)
+      end
+    end
+
+    def initialize_signals(ultravisor, config, service_signals, metrics_registry)
+      counter = metrics_registry.counter(:"#{config.service_name}_signals_handled_total", docstring: "How many of each signal have been handled", labels: %i{signal})
+
+      ultravisor.add_child(
+        id: :signal_manager,
+        klass: ServiceSkeleton::SignalManager,
+        method: :run,
+        args: [
+          logger: config.logger,
+          counter: counter,
+          signals: global_signals(ultravisor, config.logger) + wrap_service_signals(service_signals, ultravisor),
+        ],
+        shutdown: {
+          method: :shutdown,
+          timeout: 1,
+        }
+      )
+    end
+
+    def global_signals(ultravisor, logger)
+      # For mysterious reasons of mystery, simplecov doesn't recognise these
+      # procs as being called, even though there are definitely tests for
+      # them.  So...
+      #:nocov:
+      [
+        [
+          "USR1",
+          ->() {
+            logger.level -= 1 unless logger.level == Logger::DEBUG
+            logger.info($0) { "Received SIGUSR1; log level is now #{Logger::SEV_LABEL[logger.level]}." }
+          }
+        ],
+        [
+          "USR2",
+          ->() {
+            logger.level += 1 unless logger.level == Logger::ERROR
+            logger.info($0) { "Received SIGUSR2; log level is now #{Logger::SEV_LABEL[logger.level]}." }
+          }
+        ],
+        [
+          "HUP",
+          ->() {
+            logger.reopen
+            logger.info($0) { "Received SIGHUP; log file handle reopened" }
+          }
+        ],
+        [
+          "QUIT",
+          ->() { Sigdump.dump("+") }
+        ],
+        [
+          "INT",
+          ->() {
+            ultravisor.shutdown(wait: false, force: !!@shutting_down)
+            @shutting_down = true
+          }
+        ],
+        [
+          "TERM",
+          ->() {
+            ultravisor.shutdown(wait: false, force: !!@shutting_down)
+            @shutting_down = true
+          }
+        ]
+      ]
+      #:nocov:
+    end
+
+    def wrap_service_signals(signals, ultravisor)
+      [].tap do |signal_list|
+        signals.each do |service_name, sigs|
+          sigs.each do |sig, proc|
+            wrapped_proc = ->() { ultravisor[service_name.to_sym].unsafe_instance.instance_eval(&proc) }
+            signal_list << [sig, wrapped_proc]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/service_skeleton/logging_helpers.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-class ServiceSkeleton
+module 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

data/lib/service_skeleton/metric_method_name.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ServiceSkeleton
+  module MetricMethodName
+    def method_name(svc_name)
+      @name.to_s.gsub(/\A#{Regexp.quote(svc_name)}_/i, '').downcase
+    end
+  end
+end

data/lib/service_skeleton/metrics_methods.rb

@@ -1,24 +1,37 @@
 # frozen_string_literal: true
 
-class ServiceSkeleton
+require "prometheus/client"
+
+require_relative "metric_method_name"
+
+Prometheus::Client::Metric.include(ServiceSkeleton::MetricMethodName)
+
+module ServiceSkeleton
   module MetricsMethods
-    def service=(svc)
-      @service = svc
+    def registered_metrics
+      @registered_metrics || []
     end
 
-    def register(metric)
-      method_name = metric.name.to_s.gsub(/\A#{Regexp.quote(@service.service_name)}_/, '').to_sym
+    def metric(metric)
+      @registered_metrics ||= []
 
-      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
+      @registered_metrics << metric
+    end
 
-      define_singleton_method(method_name) do
-        metric
-      end
+    def counter(name, docstring:, labels: [], preset_labels: {})
+      metric(Prometheus::Client::Counter.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
+    end
+
+    def gauge(name, docstring:, labels: [], preset_labels: {})
+      metric(Prometheus::Client::Gauge.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
+    end
+
+    def summary(name, docstring:, labels: [], preset_labels: {})
+      metric(Prometheus::Client::Summary.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
+    end
 
-      super
+    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))
     end
   end
 end

data/lib/service_skeleton/runner.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "logging_helpers"
+require_relative "signal_manager"
+
+require "frankenstein/ruby_gc_metrics"
+require "frankenstein/ruby_vm_metrics"
+require "frankenstein/process_metrics"
+require "frankenstein/server"
+require "prometheus/client/registry"
+require "sigdump"
+require "ultravisor"
+
+module ServiceSkeleton
+  class Runner
+    include ServiceSkeleton::LoggingHelpers
+
+    def initialize(klass, env)
+      @config = (klass.config_class || ServiceSkeleton::Config).new(env, klass.service_name, klass.registered_variables)
+      @logger = @config.logger
+
+      @metrics_registry = Prometheus::Client::Registry.new
+
+      @ultravisor = ServiceSkeleton.generate(
+        config: @config,
+        metrics_registry: @metrics_registry,
+        service_metrics: klass.registered_metrics,
+        service_signal_handlers: { klass.service_name.to_sym => klass.registered_signal_handlers }
+      )
+
+      klass.register_ultravisor_children(@ultravisor, config: @config, metrics_registry: @metrics_registry)
+    end
+
+    def run
+      @config.pre_run_logger.info(logloc) { "Starting service #{@config.service_name}" }
+      @config.pre_run_logger.info(logloc) { (["Environment:"] + @config.env.map { |k, v| "#{k}=#{v.inspect}" }).join("\n  ") }
+
+      @ultravisor.run
+    end
+
+    private
+
+    attr_reader :logger
+  end
+end

data/lib/service_skeleton/service_name.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ServiceSkeleton
+  module ServiceName
+    def service_name
+      service_name_from_class(self)
+    end
+
+    private
+
+    def service_name_from_class(klass)
+      klass.to_s
+        .gsub("::", "_")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+        .gsub(/[^a-zA-Z0-9_]/, "_")
+    end
+  end
+end

data/lib/service_skeleton/signal_manager.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "./logging_helpers"
+
+module ServiceSkeleton
+  # Manage signals in a sane and safe manner.
+  #
+  # Signal handling is a shit of a thing.  The code that runs when a signal is
+  # triggered can't use mutexes (which are used in all sorts of places you
+  # might not expect, like Logger!) or anything else that might block.  This
+  # greatly constrains what you can do inside a signal handler, so the standard
+  # approach is to stuff a character down a pipe, and then have the *real*
+  # signal handling run later.
+  #
+  # Also, there's always the (slim) possibility that something else might have
+  # hooked into a signal we want to receive.  Because only a single signal
+  # handler can be active for a given signal at a time, we need to "chain" the
+  # existing handler, by calling the previous signal handler from our signal
+  # handler after we've done what we need to do.  This class takes care of
+  # that, too, because it's a legend.
+  #
+  # So that's what this class does: it allows you to specify signals and
+  # associated blocks of code to run, it sets up signal handlers which send
+  # notifications to a background thread and chain correctly, and it manages
+  # the background thread to receive the notifications and execute the
+  # associated blocks of code outside of the context of the signal handler.
+  #
+  class SignalManager
+    include ServiceSkeleton::LoggingHelpers
+
+    # Setup a signal handler instance.
+    #
+    # @param logger [Logger] the logger to use for all the interesting information
+    #   about what we're up to.
+    #
+    def initialize(logger:, counter:, signals:)
+      @logger, @signal_counter, @signal_list = logger, counter, signals
+
+      @registry = Hash.new { |h, k| h[k] = SignalHandler.new(k) }
+
+      @signal_list.each do |sig, proc|
+        @registry[signum(sig)] << proc
+      end
+    end
+
+    def run
+      logger.info(logloc) { "Starting signal manager for #{@signal_list.length} signals" }
+
+      @r, @w = IO.pipe
+
+      install_signal_handlers
+
+      signals_loop
+    ensure
+      remove_signal_handlers
+    end
+
+    def shutdown
+      @r.close
+    end
+
+    private
+
+    attr_reader :logger
+
+    def signals_loop
+      #:nocov:
+      loop do
+        begin
+          if ios = IO.select([@r])
+            if ios.first.include?(@r)
+              if ios.first.first.eof?
+                logger.info(logloc) { "Signal pipe closed; shutting down" }
+                break
+              else
+                c = ios.first.first.read_nonblock(1)
+                logger.debug(logloc) { "Received character #{c.inspect} from signal pipe" }
+                handle_signal(c)
+              end
+            else
+              logger.error(logloc) { "Mysterious return from select: #{ios.inspect}" }
+            end
+          end
+        rescue IOError
+          # Something has gone terribly wrong here... bail
+          break
+        rescue StandardError => ex
+          log_exception(ex) { "Exception in select loop" }
+        end
+      end
+      #:nocov:
+    end
+
+    # Given a character (presumably) received via the signal pipe, execute the
+    # associated handler.
+    #
+    # @param char [String] a single character, corresponding to an entry in the
+    #   signal registry.
+    #
+    # @return [void]
+    #
+    def handle_signal(char)
+      if @registry.has_key?(char.ord)
+        handler = @registry[char.ord]
+        logger.debug(logloc) { "#{handler.signame} received" }
+        @signal_counter.increment(labels: { signal: handler.signame.to_s })
+
+        begin
+          handler.call
+        rescue StandardError => ex
+          log_exception(ex) { "Exception while calling signal handler" }
+        end
+      else
+        logger.error(logloc) { "Unrecognised signal character: #{char.inspect}" }
+      end
+    end
+
+    def install_signal_handlers
+      @registry.values.each do |h|
+        h.write_pipe = @w
+        h.hook
+      end
+    end
+
+    def signum(spec)
+      if spec.is_a?(Integer)
+        return spec
+      end
+
+      if spec.is_a?(Symbol)
+        str = spec.to_s
+      elsif spec.is_a?(String)
+        str = spec.dup
+      else
+        raise ArgumentError,
+              "Unsupported class (#{spec.class}) of signal specifier #{spec.inspect}"
+      end
+
+      str.sub!(/\ASIG/i, '')
+
+      if Signal.list[str.upcase]
+        Signal.list[str.upcase]
+      else
+        raise ArgumentError,
+              "Unrecognised signal specifier #{spec.inspect}"
+      end
+    end
+
+    def remove_signal_handlers
+      @registry.values.each { |h| h.unhook }
+    end
+
+    class SignalHandler
+      attr_reader :signame
+      attr_writer :write_pipe
+
+      def initialize(signum)
+        @signum = signum
+        @callbacks = []
+
+        @signame = Signal.list.invert[@signum]
+      end
+
+      def <<(proc)
+        @callbacks << proc
+      end
+
+      def call
+        @callbacks.each { |cb| cb.call }
+      end
+
+      def hook
+        @handler = ->(_) do
+          #:nocov:
+          @write_pipe.write_nonblock(@signum.chr) rescue nil
+          @chain.call if @chain.respond_to?(:call)
+          #:nocov:
+        end
+
+        @chain = Signal.trap(@signum, &@handler)
+      end
+
+      def unhook
+        #:nocov:
+        tmp_handler = Signal.trap(@signum, "IGNORE")
+        if tmp_handler == @handler
+          # The current handler is ours, so we can replace it
+          # with the chained handler
+          Signal.trap(@signum, @chain)
+        else
+          # The current handler *isn't* ours, so we better
+          # put it back, because whoever owns it might get
+          # angry.
+          Signal.trap(@signum, tmp_handler)
+        end
+        #:nocov:
+      end
+    end
+
+    private_constant :SignalHandler
+  end
+end