smart_proxy_dynflow_core 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ea792e8e6d9f6ddcd145428485d5faadf92da27acd184fa42956fa4873e7fd
-  data.tar.gz: 07adc8b3c623462086d0797455afaf822e27212bcdcda345a950df7e49296814
+  metadata.gz: 467f03a2c2c0ad4e3b168039abdb8e9a465a46b8ecf44aade57c5a09bbeafbfc
+  data.tar.gz: e966e14e4a95f42af61b5bcf47595ad6afa241271656b6724e5000b3e2cd354d
 SHA512:
-  metadata.gz: 989f9619b041039a3897de03cac1edc5ce1415a19792b3a5b2e907b174b97472b3a56f19cd5cab9977c26e5d5c83c38636afe8c49186dbd2bfce1c7e3dbfcc84
-  data.tar.gz: 7caa3ee4ddce3560970bd8f7a7b8e2b99dd96f1fae456e78475673ec98478e0c608e5feb29442b7046e4eed07e61f0d9a009dade6646e534f6ef6f033192f572
+  metadata.gz: e6a3b2b7b4dc313c1b6cc215c2de6cda4f49ad9f901bc7ab949b0ed4a16521e021b9c39a0fc371091e54172610787f968a2bb8577f68086ef15308bd805fc970
+  data.tar.gz: 7cbfc949016d5d824ebbb421093c8ef687c24d33c6699e7ef0c875145e035e8233317ff64c7757597bd0e76c9186566dec4e407397e32803b6d42ea26602fb6f

data/Gemfile

@@ -10,28 +10,14 @@ group :test do
   gem 'smart_proxy', :git => "https://github.com/theforeman/smart-proxy", :branch => "develop"
   gem 'smart_proxy_dynflow', :path => '.'
 
-  if RUBY_VERSION < '2.1'
-    gem 'public_suffix', '< 3'
-    gem 'rainbow', '< 3'
-  else
-    gem 'public_suffix'
-    gem 'rubocop', '~> 0.52.1'
-  end
-
-  if RUBY_VERSION < '2.2'
-    gem 'rack-test', '< 0.8'
-  else
-    gem 'rack-test'
-  end
+  gem 'public_suffix'
+  gem 'rack-test'
+  gem 'rubocop', '~> 0.52.1'
 end
 
-if RUBY_VERSION < '2.2'
-  gem 'rack', '>= 1.1', '< 2.0.0'
-  gem 'sinatra', '< 2'
-else
-  gem 'rack', '>= 1.1'
-  gem 'sinatra'
-end
+gem 'logging-journald', '~> 2.0', :platforms => [:ruby]
+gem 'rack', '>= 1.1'
+gem 'sinatra'
 
 # load bundler.d
 Dir["#{File.dirname(__FILE__)}/bundler.d/*.rb"].each do |bundle|

data/config/settings.yml.example

@@ -39,11 +39,27 @@
 # Specify versions like: '1.1', or '1.2'
 #:tls_disabled_versions: []
 
-# File to log to, leave empty for logging to STDOUT
-# :log_file: /var/log/foreman-proxy/smart_proxy_dynflow_core.log
+# File to log to, leave empty for stdout or use STDOUT, STDERR, SYSLOG or JOURNAL
+#:log_file: /var/log/foreman-proxy/smart_proxy_dynflow_core.log
 
 # Log level, one of UNKNOWN, FATAL, ERROR, WARN, INFO, DEBUG
-# :log_level: ERROR
+#:log_level: ERROR
+
+# The maximum size of a log file before it's rolled (in MiB) or zero to disable file rolling
+# and rely on logrotate or similar tool
+#:file_rolling_size: 0
+
+# The maximum age of a log file before it's rolled (in seconds). Also accepts 'daily', 'weekly', or 'monthly'.
+#:file_rolling_age: weekly
+
+# Number of log files to keep
+#:file_rolling_keep: 6
+
+# Logging pattern for file-based loging
+#:file_logging_pattern: '%d %.8X{request} [%.1l] %m'
+
+# Logging pattern for syslog or journal loging
+#:system_logging_pattern: '%.8X{request} [%.1l] %m'
 
 # Maximum age of execution plans to keep before having them cleaned
 # by the execution plan cleaner (in seconds), defaults to 24 hours

data/lib/smart_proxy_dynflow_core.rb

@@ -1,6 +1,7 @@
-raise LoadError, 'Ruby >= 2.1 is required' unless RUBY_VERSION >= '2.1'
-
 require 'dynflow'
+require 'smart_proxy_dynflow_core/request_id_middleware'
+require 'smart_proxy_dynflow_core/logger_middleware'
+require 'smart_proxy_dynflow_core/middleware/keep_current_request_id'
 require 'smart_proxy_dynflow_core/task_launcher_registry'
 require 'foreman_tasks_core'
 require 'smart_proxy_dynflow_core/log'

data/lib/smart_proxy_dynflow_core/api.rb

@@ -6,6 +6,14 @@ module SmartProxyDynflowCore
     TASK_UPDATE_REGEXP_PATH = %r{/tasks/(\S+)/(update|done)}
     helpers Helpers
 
+    configure do
+      if Settings.instance.standalone
+        ::Sinatra::Base.set :logging, false
+        ::Sinatra::Base.use ::SmartProxyDynflowCore::RequestIdMiddleware
+        ::Sinatra::Base.use ::SmartProxyDynflowCore::LoggerMiddleware
+      end
+    end
+
     before do
       if match = request.path_info.match(TASK_UPDATE_REGEXP_PATH)
         task_id = match[1]

data/lib/smart_proxy_dynflow_core/bundler_helper.rb

@@ -1,6 +1,5 @@
 module SmartProxyDynflowCore
   class BundlerHelper
-    # rubocop:disable Metrics/PerceivedComplexity
     def self.require_groups(*groups)
       if File.exist?(File.expand_path('../../../Gemfile.in', __FILE__))
         # If there is a Gemfile.in file, we will not use Bundler but BundlerExt

data/lib/smart_proxy_dynflow_core/callback.rb

@@ -15,7 +15,6 @@ module SmartProxyDynflowCore
           self.new.callback(prepare_payload(callback_info, data))
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
         def ssl_options
           return @ssl_options if defined? @ssl_options
           @ssl_options = {}

data/lib/smart_proxy_dynflow_core/core.rb

@@ -15,7 +15,9 @@ module SmartProxyDynflowCore
 
     def create_world(&block)
       config = default_world_config(&block)
-      ::Dynflow::World.new(config)
+      world = ::Dynflow::World.new(config)
+      world.middleware.use ::Actions::Middleware::KeepCurrentRequestID
+      world
     end
 
     def persistence_conn_string

data/lib/smart_proxy_dynflow_core/launcher.rb

@@ -1,7 +1,7 @@
 require 'webrick/https'
 require 'smart_proxy_dynflow_core/bundler_helper'
 require 'smart_proxy_dynflow_core/settings'
-require 'smart_proxy_dynflow_core/sd_notify'
+require 'sd_notify'
 
 module SmartProxyDynflowCore
   class Launcher
@@ -14,13 +14,15 @@ module SmartProxyDynflowCore
     end
 
     def start(options)
-      load_settings!(options)
       Settings.instance.standalone = true
+      load_settings!(options)
       install_usr1_trap
       Rack::Server.new(rack_settings).start do |_server|
         SmartProxyDynflowCore::Core.ensure_initialized
-        SmartProxyDynflowCore::SdNotify.new.tap { |sd| sd.ready if sd.active? }
+        ::SdNotify.ready
       end
+      Log.instance.info "Finished shutting down"
+      Logging.shutdown
     end
 
     def load_settings!(options = {})
@@ -53,7 +55,7 @@ module SmartProxyDynflowCore
 
     def install_usr1_trap
       trap(:USR1) do
-        Log.instance.roll_log
+        Log.reopen
       end
     end
 
@@ -81,7 +83,7 @@ module SmartProxyDynflowCore
         :app => app,
         :Host => Settings.instance.listen,
         :Port => Settings.instance.port,
-        :AccessLog => [[Log.instance, WEBrick::AccessLog::COMMON_LOG_FORMAT]],
+        :AccessLog => [],
         :Logger => Log.instance,
         :daemonize => Settings.instance.daemonize,
         :pid => Settings.instance.daemonize && Settings.instance.pid_file,
@@ -89,7 +91,6 @@ module SmartProxyDynflowCore
       }
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
     def https_app
       ssl_options  = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
       ssl_options |= OpenSSL::SSL::OP_CIPHER_SERVER_PREFERENCE if defined?(OpenSSL::SSL::OP_CIPHER_SERVER_PREFERENCE)
@@ -99,16 +100,14 @@ module SmartProxyDynflowCore
       ssl_options |= OpenSSL::SSL::OP_NO_TLSv1 if defined?(OpenSSL::SSL::OP_NO_TLSv1)
       ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_1 if defined?(OpenSSL::SSL::OP_NO_TLSv1_1)
 
-      if Settings.instance.tls_disabled_versions
-        Settings.instance.tls_disabled_versions.each do |version|
-          constant = OpenSSL::SSL.const_get("OP_NO_TLSv#{version.to_s.tr('.', '_')}") rescue nil
+      Settings.instance.tls_disabled_versions&.each do |version|
+        constant = OpenSSL::SSL.const_get("OP_NO_TLSv#{version.to_s.tr('.', '_')}") rescue nil
 
-          if constant
-            Log.instance.info "TLSv#{version} will be disabled."
-            ssl_options |= constant
-          else
-            Log.instance.warn "TLSv#{version} was not found."
-          end
+        if constant
+          Log.instance.info "TLSv#{version} will be disabled."
+          ssl_options |= constant
+        else
+          Log.instance.warn "TLSv#{version} was not found."
         end
       end
 

data/lib/smart_proxy_dynflow_core/log.rb

@@ -1,61 +1,126 @@
-require 'logger'
+require 'logging'
 
 module SmartProxyDynflowCore
-  class Log < ::Logger
-    alias_method :write, :debug
+  class ReopenAppender < ::Logging::Appender
+    def initialize(name, logger, opts = {})
+      @reopen = false
+      @logger = logger
+      super(name, opts)
+    end
 
-    class << self
-      def instance
-        if @logger.nil?
-          @logger = self.new log_file
-          @logger.level = log_level
-        end
-        @logger
-      end
+    def set(status = true)
+      @reopen = status
+    end
 
-      def instance=(logger)
-        @logger = logger
+    def append(_event)
+      if @reopen
+        Logging.reopen
+        @reopen = false
       end
+    end
+  end
+
+  class Log
+    BASE_LOG_SIZE = 1024 * 1024 # 1 MiB
+    LOGGER_NAME = 'dynflow-core'.freeze
+
+    begin
+      require 'syslog/logger'
+      @syslog_available = true
+    rescue LoadError
+      @syslog_available = false
+    end
 
+    class << self
       def reload!
+        Logging.logger[LOGGER_NAME].appenders.each(&:close)
+        Logging.logger[LOGGER_NAME].clear_appenders
         @logger = nil
         instance
       end
 
-      def log_level
-        if Settings.instance.loaded && Settings.instance.log_level
-          ::Logger.const_get(Settings.instance.log_level.upcase)
-        else
-          Logger::WARN
+      def reopen
+        return if @logger.nil? || @reopen.nil?
+        if Settings.instance.log_file !~ /^(STDOUT|SYSLOG|JOURNALD?)$/i
+          @reopen.set
         end
       end
 
-      def log_file
-        if Settings.instance.loaded && Settings.instance.log_file
-          Settings.instance.log_file
+      def instance
+        return ::Proxy::LogBuffer::Decorator.instance unless Settings.instance.standalone
+        return @logger if @logger
+        layout = Logging::Layouts.pattern(pattern: Settings.instance.file_logging_pattern + "\n")
+        notime_layout = Logging::Layouts.pattern(pattern: Settings.instance.system_logging_pattern + "\n")
+        log_file = Settings.instance.log_file || ''
+        @logger = Logging.logger[LOGGER_NAME]
+        @reopen = ReopenAppender.new("Reopen dummy appender", @logger)
+        @logger.add_appenders(@reopen)
+        if !Settings.instance.loaded || log_file.casecmp('STDOUT').zero?
+          @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+        elsif log_file.casecmp('SYSLOG').zero?
+          unless @syslog_available
+            puts "Syslog is not supported on this platform, use STDOUT or a file"
+            exit(1)
+          end
+          @logger.add_appenders(Logging.appenders.syslog(LOGGER_NAME, layout: notime_layout, facility: ::Syslog::Constants::LOG_LOCAL5))
+        elsif log_file.casecmp('JOURNAL').zero? || log_file.casecmp('JOURNALD').zero?
+          begin
+            @logger.add_appenders(Logging.appenders.journald(LOGGER_NAME, LOGGER_NAME: :proxy_logger, layout: notime_layout, facility: ::Syslog::Constants::LOG_LOCAL5))
+          rescue NoMethodError
+            @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+            @logger.warn "Journald is not available on this platform. Falling back to STDOUT."
+          end
         else
-          $stdout
+          begin
+            keep = Settings.instance.file_rolling_keep
+            size = BASE_LOG_SIZE * Settings.instance.file_rolling_size
+            age = Settings.instance.file_rolling_age
+            if size.positive?
+              @logger.add_appenders(Logging.appenders.rolling_file(LOGGER_NAME, layout: layout, filename: log_file, keep: keep, size: size, age: age, roll_by: 'number'))
+            else
+              @logger.add_appenders(Logging.appenders.file(LOGGER_NAME, layout: layout, filename: log_file))
+            end
+          rescue ArgumentError => ae
+            @logger.add_appenders(Logging.appenders.stdout(LOGGER_NAME, layout: layout))
+            @logger.warn "Log file #{log_file} cannot be opened. Falling back to STDOUT: #{ae}"
+          end
         end
+        @logger.level = ::Logging.level_num(Settings.instance.log_level)
+        @logger
       end
-    end
 
-    def initialize(file, *rest)
-      @file = file
-      @fd = @file.is_a?(IO) ? @file : File.open(@file, 'a')
-      @fd.sync = true
-      super(@fd, rest)
-    end
+      def with_fields(fields = {})
+        ::Logging.ndc.push(fields) do
+          yield
+        end
+      end
 
-    def roll_log
-      unless @file.is_a? IO
-        @fd.reopen @file, 'a'
-        @fd.sync = true
+      # Standard way for logging exceptions to get the most data in the log. By default
+      # it logs via warn level, this can be changed via options[:level]
+      def exception(context_message, exception, options = {})
+        level = options[:level] || :warn
+        unless ::Logging::LEVELS.keys.include?(level.to_s)
+          raise "Unexpected log level #{level}, expected one of #{::Logging::LEVELS.keys}"
+        end
+        # send class, message and stack as structured fields in addition to message string
+        backtrace = exception.backtrace ? exception.backtrace : []
+        extra_fields = {
+          exception_class: exception.class.name,
+          exception_message: exception.message,
+          exception_backtrace: backtrace
+        }
+        extra_fields[:foreman_code] = exception.code if exception.respond_to?(:code)
+        with_fields(extra_fields) do
+          @logger.public_send(level) do
+            ([context_message, "#{exception.class}: #{exception.message}"] + backtrace).join("\n")
+          end
+        end
       end
     end
 
     class ProxyStructuredFormater < ::Dynflow::LoggerAdapters::Formatters::Abstract
-      def call(_severity, _datetime, _prog_name, message)
-        if message.is_a?(::Exception)
+      def format(message)
+        if message.is_a?(Exception)
           subject = "#{message.message} (#{message.class})"
           if @base.respond_to?(:exception)
             @base.exception("Error details", message)
@@ -64,22 +129,17 @@ module SmartProxyDynflowCore
             "#{subject}\n#{message.backtrace.join("\n")}"
           end
         else
-          message
+          @original_formatter.call(severity, datetime, prog_name, message)
         end
       end
-
-      def format(message)
-        call(nil, nil, nil, message)
-      end
     end
 
     class ProxyAdapter < ::Dynflow::LoggerAdapters::Simple
       def initialize(logger, level = Logger::DEBUG, _formatters = [])
         @logger           = logger
         @logger.level     = level
-        @logger.formatter = ProxyStructuredFormater.new(@logger)
-        @action_logger    = apply_formatters(ProgNameWrapper.new(@logger, ' action'), [ProxyStructuredFormater])
-        @dynflow_logger   = apply_formatters(ProgNameWrapper.new(@logger, 'dynflow'), [ProxyStructuredFormater])
+        @action_logger    = apply_formatters(ProgNameWrapper.new(@logger, ' action'), [])
+        @dynflow_logger   = apply_formatters(ProgNameWrapper.new(@logger, 'dynflow'), [])
       end
     end
   end

data/lib/smart_proxy_dynflow_core/logger_middleware.rb

@@ -0,0 +1,31 @@
+module SmartProxyDynflowCore
+  class LoggerMiddleware
+    def initialize(app)
+      @logger = SmartProxyDynflowCore::Log.instance
+      @app = app
+    end
+
+    def call(env)
+      before = Time.now.to_f
+      status = 500
+      env['rack.logger'] = @logger
+      @logger.info { "Started #{env['REQUEST_METHOD']} #{env['PATH_INFO']} #{env['QUERY_STRING']}" }
+      @logger.debug { 'Headers: ' + env.select { |k, v| k.start_with? 'HTTP_' }.inspect }
+      if @logger.debug? && env['rack.input']
+        body = env['rack.input'].read
+        @logger.debug('Body: ' + body) unless body.empty?
+        env['rack.input'].rewind
+      end
+      status, = @app.call(env)
+    rescue Exception => e
+      Log.exception "Error processing request '#{::Logging.mdc['request']}", e
+      raise e
+    ensure
+      @logger.info do
+        after = Time.now.to_f
+        duration = (after - before) * 1000
+        "Finished #{env['REQUEST_METHOD']} #{env['PATH_INFO']} with #{status} (#{duration.round(2)} ms)"
+      end
+    end
+  end
+end

data/lib/smart_proxy_dynflow_core/request_id_middleware.rb

@@ -0,0 +1,18 @@
+module SmartProxyDynflowCore
+  class RequestIdMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      ::Logging.mdc['remote_ip'] = env['REMOTE_ADDR']
+      if env.has_key?('HTTP_X_REQUEST_ID')
+        ::Logging.mdc['request'] = env['HTTP_X_REQUEST_ID']
+      else
+        ::Logging.mdc['request'] = SecureRandom.uuid
+      end
+      status, header, body = @app.call(env)
+      [status, header, ::Rack::BodyProxy.new(body) { ::Logging.mdc.clear }]
+    end
+  end
+end

data/lib/smart_proxy_dynflow_core/settings.rb

@@ -1,22 +1,5 @@
 require 'ostruct'
 
-# Implement hash-like access for 1.9.3 and older
-if RUBY_VERSION.split('.').first.to_i < 2
-  class OpenStruct
-    def [](key)
-      self.send key
-    end
-
-    def []=(key, value)
-      self.send "#{key}=", value
-    end
-
-    def to_h
-      marshal_dump
-    end
-  end
-end
-
 module SmartProxyDynflowCore
   class Settings < OpenStruct
     DEFAULT_SETTINGS = {
@@ -41,7 +24,12 @@ module SmartProxyDynflowCore
       :pid_file => '/var/run/foreman-proxy/smart_proxy_dynflow_core.pid',
       :daemonize => false,
       :execution_plan_cleaner_age => 60 * 60 * 24,
-      :loaded => false
+      :loaded => false,
+      :file_logging_pattern => '%d %.8X{request} [%.1l] %m',
+      :system_logging_pattern => '%.8X{request} [%.1l] %m',
+      :file_rolling_keep => 6,
+      :file_rolling_size => 0,
+      :file_rolling_age => 'weekly'
     }.freeze
 
     PROXY_SETTINGS = %i[ssl_ca_file ssl_certificate ssl_private_key foreman_url
@@ -73,13 +61,7 @@ module SmartProxyDynflowCore
     end
 
     def self.load_from_proxy(plugin)
-      plugin_class = if Proxy::VERSION >= '1.16.0'
-                       plugin
-                     else
-                       # DEPRECATION: Remove this branch when dropping support for smart-proxy < 1.16
-                       plugin[:class]
-                     end
-      settings = plugin_class.settings.to_h
+      settings = plugin.settings.to_h
       PROXY_SETTINGS.each do |key|
         SETTINGS[key] = Proxy::SETTINGS[key]
       end

data/lib/smart_proxy_dynflow_core/version.rb

@@ -1,3 +1,3 @@
 module SmartProxyDynflowCore
-  VERSION = '0.2.6'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/smart_proxy_dynflow_core.gemspec

@@ -2,7 +2,6 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'smart_proxy_dynflow_core/version'
 
-# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |gem|
   gem.name          = "smart_proxy_dynflow_core"
   gem.version       = SmartProxyDynflowCore::VERSION
@@ -22,6 +21,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.license = 'GPL-3.0'
 
+  gem.required_ruby_version = '~> 2.5'
+
   gem.add_development_dependency "bundler", ">= 1.7"
   gem.add_development_dependency('minitest')
   gem.add_development_dependency('mocha', '~> 1')
@@ -31,10 +32,11 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency('dynflow', "~> 1.1")
   gem.add_runtime_dependency('foreman-tasks-core', '>= 0.3.3')
+  gem.add_runtime_dependency('logging')
   gem.add_runtime_dependency('rack')
   gem.add_runtime_dependency('rest-client')
+  gem.add_runtime_dependency('sd_notify', '~> 0.1')
   gem.add_runtime_dependency('sequel')
   gem.add_runtime_dependency('sinatra')
   gem.add_runtime_dependency('sqlite3')
 end
-# rubocop:enable Metrics/BlockLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dynflow_core
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Nečas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-19 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sd_notify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -214,7 +242,8 @@ files:
 - lib/smart_proxy_dynflow_core/helpers.rb
 - lib/smart_proxy_dynflow_core/launcher.rb
 - lib/smart_proxy_dynflow_core/log.rb
-- lib/smart_proxy_dynflow_core/sd_notify.rb
+- lib/smart_proxy_dynflow_core/logger_middleware.rb
+- lib/smart_proxy_dynflow_core/request_id_middleware.rb
 - lib/smart_proxy_dynflow_core/settings.rb
 - lib/smart_proxy_dynflow_core/task_launcher_registry.rb
 - lib/smart_proxy_dynflow_core/testing.rb
@@ -224,23 +253,23 @@ homepage: https://github.com/theforeman/smart_proxy_dynflow
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Dynflow runtime for Foreman smart proxy
 test_files: []

data/lib/smart_proxy_dynflow_core/sd_notify.rb

@@ -1,33 +0,0 @@
-# Shamelessly taken from theforeman/smart-proxy @ 99e9e5b
-# kudos to domcleal
-
-require 'socket'
-
-# Implementation of libsystemd's sd_notify API, sends current state via socket
-module SmartProxyDynflowCore
-  class SdNotify
-    def active?
-      !ENV['NOTIFY_SOCKET'].nil?
-    end
-
-    def notify(message)
-      create_socket.tap do |socket|
-        socket.sendmsg(message.chomp + "\n") # ensure trailing \n
-        socket.close
-      end
-    end
-
-    def ready(state = 1)
-      notify("READY=#{state}")
-    end
-
-    private
-
-    def create_socket
-      raise 'Missing NOTIFY_SOCKET environment variable, is this process running under systemd?' unless active?
-      Socket.new(Socket::AF_UNIX, Socket::SOCK_DGRAM, 0).tap do |socket|
-        socket.connect(Socket.pack_sockaddr_un(ENV['NOTIFY_SOCKET']))
-      end
-    end
-  end
-end