service_skeleton 0.0.0.30.g32b8169 → 0.0.0.48.g4a40599

data/lib/service_skeleton/logging_helpers.rb

@@ -1,21 +1,23 @@
-class ServiceSkeleton
+# frozen_string_literal: true
+
+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,22 +1,37 @@
-class ServiceSkeleton
+# frozen_string_literal: true
+
+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 metric(metric)
+      @registered_metrics ||= []
+
+      @registered_metrics << metric
     end
 
-    def register(metric)
-      method_name = metric.name.to_s.gsub(/\A#{Regexp.quote(@service.service_name)}_/, '').to_sym
+    def counter(name, docstring:, labels: [], preset_labels: {})
+      metric(Prometheus::Client::Counter.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 gauge(name, docstring:, labels: [], preset_labels: {})
+      metric(Prometheus::Client::Gauge.new(name, docstring: docstring, labels: labels, preset_labels: preset_labels))
+    end
 
-      define_singleton_method(method_name) do
-        metric
-      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
+      logger.info(logloc) { "Starting service #{@config.service_name}" }
+      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

data/lib/service_skeleton/signals_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ServiceSkeleton
+  module SignalsMethods
+    def registered_signal_handlers
+      @registered_signal_handlers || []
+    end
+
+    def hook_signal(sigspec, &blk)
+      @registered_signal_handlers ||= []
+
+      @registered_signal_handlers << [sigspec, blk]
+    end
+  end
+end

data/lib/service_skeleton/ultravisor_children.rb

@@ -0,0 +1,17 @@
+module ServiceSkeleton
+  module UltravisorChildren
+    def register_ultravisor_children(ultravisor, config:, metrics_registry:)
+      begin
+        ultravisor.add_child(
+          id: self.service_name.to_sym,
+          klass: self,
+          method: :run,
+          args: [config: config, metrics: metrics_registry]
+        )
+      rescue Ultravisor::InvalidKAMError
+        raise ServiceSkeleton::Error::InvalidServiceClassError,
+              "Class #{self.to_s} does not implement the `run' instance method"
+      end
+    end
+  end
+end

data/lib/service_skeleton/ultravisor_loggerstash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ServiceSkeleton
+  module UltravisorLoggerstash
+    def logstash_writer
+      #:nocov:
+      @ultravisor[:logstash_writer].unsafe_instance
+      #:nocov:
+    end
+  end
+end

data/service_skeleton.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'git-version-bump'
 rescue LoadError
@@ -30,14 +32,12 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 2.5.0"
 
-  s.add_runtime_dependency "frankenstein", "~> 1.2"
-  s.add_runtime_dependency "loggerstash", "~> 0.0"
-  # prometheus-client provides no guaranteed backwards compatibility,
-  # and in fact happily breaks things with no notice, so we're stuck
-  # with hard-coding a specific version to avoid unexpected disaster.
-  s.add_runtime_dependency "prometheus-client", "0.8.0"
+  s.add_runtime_dependency "frankenstein", "~> 2.0"
+  s.add_runtime_dependency "loggerstash", ">= 0.0.9", "< 1"
+  s.add_runtime_dependency "prometheus-client", "~> 2.0"
   s.add_runtime_dependency "sigdump", "~> 0.2"
   s.add_runtime_dependency "to_regexp", "~> 0.2"
+  s.add_runtime_dependency "ultravisor", "~> 0.a"
 
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'github-release'
@@ -48,7 +48,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', "~> 12.0"
   s.add_development_dependency 'redcarpet'
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop', "~> 0.79"
+  s.add_development_dependency 'rubocop-discourse'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: service_skeleton
 version: !ruby/object:Gem::Version
-  version: 0.0.0.30.g32b8169
+  version: 0.0.0.48.g4a40599
 platform: ruby
 authors:
 - Matt Palmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-04 00:00:00.000000000 Z
+date: 2020-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: frankenstein
@@ -16,42 +16,48 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: loggerstash
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: 0.0.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: prometheus-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: sigdump
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +86,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: ultravisor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.a
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.a
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -208,6 +228,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.79'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.79'
+- !ruby/object:Gem::Dependency
+  name: rubocop-discourse
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -271,15 +305,31 @@ files:
 - LICENCE
 - README.md
 - lib/service_skeleton.rb
-- lib/service_skeleton/background_worker.rb
 - lib/service_skeleton/config.rb
+- lib/service_skeleton/config_class.rb
 - lib/service_skeleton/config_variable.rb
+- lib/service_skeleton/config_variable/boolean.rb
+- lib/service_skeleton/config_variable/enum.rb
+- lib/service_skeleton/config_variable/float.rb
+- lib/service_skeleton/config_variable/integer.rb
+- lib/service_skeleton/config_variable/kv_list.rb
+- lib/service_skeleton/config_variable/path_list.rb
+- lib/service_skeleton/config_variable/string.rb
+- lib/service_skeleton/config_variable/url.rb
+- lib/service_skeleton/config_variable/yaml_file.rb
 - lib/service_skeleton/config_variables.rb
 - lib/service_skeleton/error.rb
 - lib/service_skeleton/filtering_logger.rb
+- lib/service_skeleton/generator.rb
 - lib/service_skeleton/logging_helpers.rb
+- lib/service_skeleton/metric_method_name.rb
 - lib/service_skeleton/metrics_methods.rb
-- lib/service_skeleton/signal_handler.rb
+- lib/service_skeleton/runner.rb
+- lib/service_skeleton/service_name.rb
+- lib/service_skeleton/signal_manager.rb
+- lib/service_skeleton/signals_methods.rb
+- lib/service_skeleton/ultravisor_children.rb
+- lib/service_skeleton/ultravisor_loggerstash.rb
 - service_skeleton.gemspec
 homepage: https://github.com/discourse/service_skeleton
 licenses: []
@@ -299,7 +349,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: The bare bones of a service