stack-service-base 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bba98b01bd4c3b322fe9ccef0ae2fd8fa910e19f67d6d42c8d8c8f472e1f739
-  data.tar.gz: 063cdf24707f9523bf8892677826a31713b850021d6bda4b31b3e6922e7f7f7f
+  metadata.gz: fa21c7280d1fea0d4989a72123bb927756c126d8ab0dda9d155392e70a78d113
+  data.tar.gz: 8bdb53ae89c3bf2480bfb89ac3c056d744678a25f04fef31a50ef524d4c40cfe
 SHA512:
-  metadata.gz: a300526788946d772dc4241132a1ccffc311c70a6f004ffd91b41f79f8bf26f176845abe56becbc208b40dcece8c319a582bd1ee645aedffd07ae797def6abed
-  data.tar.gz: 50822031975f44ac1871ba31dd616bab4d657ba4cdd7ae17a7de7153540a2c2878a3308f4693327b9f51cfb0cc198d1a7a0121ed467e2073650f137646665b38
+  metadata.gz: 79cf73453d710651ad3c8f9da19b1e29af8edd9b5af0097bf68b77fcd3a755ca4116c0a01d980783e9023c71b8c3d20b1836a792074985cc44e3ee487540f65e
+  data.tar.gz: 4a14e9d3b7ca39ebeb02e8aaef4d5d3a83988ba4b5d46471dd6484640bd8970da5f487c1ca5e121591a23d407b716a3205e80405634b4679c81298a12e7224da

data/lib/stack-service-base/logging.rb

@@ -0,0 +1,141 @@
+require 'console'
+require 'fiber'
+
+QUIET = ENV.fetch('CONSOLE_LEVEL', 'false') == 'true'
+PERFORMANCE = ENV.fetch('PERFORMANCE', 'false') == 'true'
+
+ENV['CONSOLE_LEVEL'] ||= 'all' unless QUIET || PERFORMANCE
+
+CONSOLE_LOGGER = Class.new {
+  def <<(...) = Console.logger.info(...)
+  def info(...) = Console.logger.info(...)
+  def debug(...) = Console.logger.debug(...)
+  def debug1(...) = Console.logger.debug(...)
+  def debug2(...) = Console.logger.debug(...)
+  def debug3(...) = Console.logger.debug(...)
+  def warn(...) = Console.logger.warn(...)
+  def error(...) = Console.logger.error(...)
+  def fatal(...) = Console.logger.fatal(...)
+}.new
+
+if QUIET
+  ENV['CONSOLE_LEVEL'] = 'error'
+  LOGGER = CONSOLE_LOGGER
+
+  # LOGGER = Class.new {
+  #   def <<(...) = nil
+  #   def info(...) = nil
+  #   def debug(...) = nil
+  #   def debug1(...) = nil
+  #   def debug2(...) = nil
+  #   def debug3(...) = nil
+  #   def warn(...) = nil
+  #   def error(...) = nil
+  #   def fatal(...) = nil
+  # }.new
+else
+  $stdout.sync = true
+  $stderr.sync = true
+  # class Fiber
+  #   alias_method :old_init, :initialize
+  #   attr_reader :parent
+  #
+  #   def initialize(&)
+  #     @parent = Fiber.current
+  #     old_init(&)
+  #   end
+  #
+  #   def parents
+  #     list = [@parent]
+  #     list << list.last.parent while list.last.respond_to?(:parent) && !list.last.parent.nil?
+  #     list
+  #   end
+  # end
+
+  # https://socketry.github.io/traces/guides/getting-started/index.html
+  # OpenTelemetry / Datadog
+  # https://socketry.github.io/console/guides/getting-started/index.html
+  # ENV['TRACES_BACKEND'] = 'traces/backend/console'
+  # ENV['CONSOLE_LEVEL'] = 'all'
+  # ENV['CONSOLE_OUTPUT'] = 'XTerm' # JSON,Text,XTerm,Default
+  # TRACE_METHODS = true
+  TRACE_METHODS ||= !PERFORMANCE unless defined? TRACE_METHODS
+  if TRACE_METHODS
+    trace = TracePoint.new(:call, :return, :b_call, :b_return) { |tp| # :thread_begin, :thread_end
+      call_stack = Thread.current[:call_stack] ||= {}
+      call_stack_fiber = call_stack[Fiber.current.__id__] ||= []
+      call_stack_fiber << [tp.defined_class, tp.method_id] if [:call, :b_call].include? tp.event
+      call_stack_fiber.pop if [:return, :b_return].include? tp.event
+    }
+    trace.enable
+  end
+  # the_method
+  # trace.disable
+  LOG_DEPTH ||= 10 unless defined? LOG_DEPTH
+  LOGGER = Class.new {
+    def initialize = @context_list ||= {}
+
+    def add_context(name)
+      task = Async::Task.current?
+      @context_list[task.__id__] = name
+    end
+
+    def find_context
+      return '' unless Thread.current[:async_task]
+
+      t_stack = [Async::Task.current]
+      t_stack << t_stack.last.parent while t_stack.last.parent
+      task = t_stack.find { @context_list[_1.__id__] }
+
+      task ? " [#{@context_list[task.__id__]}] " : ''
+    end
+
+    def <<(...) = do_log(:info, ...)
+
+    def info(...) = do_log(:info, ...)
+
+    def debug(...) = do_log(:debug, ...)
+
+    def debug1(...) = do_log(:debug1, ...)
+
+    def debug2(...) = do_log(:debug2, ...)
+
+    def debug3(...) = do_log(:debug3, ...)
+
+    def warn(...) = do_log(:warn, ...)
+
+    def error(...) = do_log(:error, ...)
+
+    def fatal(...) = do_log(:fatal, ...)
+
+    def do_log(name, *args)
+      debug_level = name[/(\d+)/, 1].to_i
+      unless debug_level > LOG_DEPTH
+        if TRACE_METHODS
+          call_stack = Thread.current[:call_stack] ||= {}
+          call_stack_fiber = call_stack[Fiber.current.__id__] ||= []
+          last = call_stack_fiber[-3] ? call_stack_fiber[-3].join('.').gsub('Class:', '').gsub(/[#<>]/, '') : ''
+          last += find_context
+          msg = "\e[33m#{last}:\e[0m \e[38;5;254m" + args.flatten.map(&:inspect).join(', ')
+        else
+          msg = args.flatten.map(&:inspect).join(', ')
+        end
+        _name = name.to_s.gsub(/\d/, '')
+        _name = 'info' if _name == '<<'
+        Console.logger.send _name.to_s.gsub(/\d/, ''), msg
+      end
+    end
+  }.new
+
+end
+
+LOGGER_GRAPE = Class.new {
+  def method_missing(name, d)
+    Console.logger.send  name, "REST_API: #{d[:method]} #{d[:path]} #{d[:params]} - #{d[:status]} host:#{d[:host]} time:#{d[:time]}"
+  end
+}.new
+
+$stdout.puts "QUIET: #{QUIET}"
+$stdout.puts "PERFORMANCE: #{PERFORMANCE}"
+
+ENV.select{ |k,v| k =~ /CONSOLE_/}.each { |k,v| $stdout.puts "#{k}: #{v}"}

data/lib/stack-service-base/open_telemetry.rb

@@ -0,0 +1,182 @@
+ENV['OTEL_LOG_LEVEL'] ||= 'debug'
+ENV['OTEL_TRACES_EXPORTER'] ||= 'console,otlp'
+
+unless defined? OTEL_ENABLED
+  OTEL_ENABLED = !ENV['OTEL_EXPORTER_OTLP_ENDPOINT'].to_s.empty?
+end
+$stdout.puts "OTEL_ENABLED: #{OTEL_ENABLED}"
+
+# require 'async'
+# require 'grape'
+
+if OTEL_ENABLED
+  STACK_NAME = ENV['STACK_NAME'] || 'undefined_stack'
+  SERVICE_NAME = ENV['STACK_SERVICE_NAME'] || 'undefined_service'
+  ENV['OTEL_RESOURCE_ATTRIBUTES'] ||= "deployment.environment=#{STACK_NAME},service.name=#{SERVICE_NAME}"
+  ENV.select{ |k,v| k =~ /OTEL/}.each { |k,v| $stdout.puts "#{k}: #{v}"}
+
+  require 'opentelemetry/sdk'
+  require 'opentelemetry/exporter/otlp'
+  require 'opentelemetry/instrumentation/all'
+  require 'opentelemetry-api'
+end
+
+if defined? Async::Task and OTEL_ENABLED
+  module AsyncTaskOTELPatch
+    def initialize(parent = Task.current?, finished: nil, **options, &block)
+      ctx_ = OpenTelemetry::Context.current
+
+      block_otl = ->(t, *arguments){
+        OpenTelemetry::Context.with_current(ctx_) do
+          block.call t, *arguments
+        end
+      }
+      super parent, finished: , **options, &block_otl
+    end
+  end
+
+  Async::Task.prepend AsyncTaskOTELPatch
+end
+
+def flatten_hash(hash, path = [], result = {})
+  hash.each do |k, v|
+    path += [k]
+    result[path.join('.')] = v.to_s if v.is_a?(String) || v.is_a?(Numeric)
+    flatten_hash(v, path, result) if v.is_a?(Hash) || v.is_a?(Array)
+    path.pop
+  end
+  result
+end
+
+if defined? LOGGER and OTEL_ENABLED
+  OpenTelemetry.logger = LOGGER
+end
+
+def otel_initialize(app)
+  $stdout.puts "otl_configure: OTEL_ENABLED: #{OTEL_ENABLED}"
+  return unless OTEL_ENABLED
+
+  OpenTelemetry::SDK.configure do |c|
+    # c.service_name = SERVICE_NAME
+    c.use_all # enables all instrumentation!
+  end
+
+  at_exit do
+    OpenTelemetry.tracer_provider.force_flush
+    OpenTelemetry.tracer_provider.shutdown
+  end
+
+  $tracer_ = OpenTelemetry.tracer_provider.tracer(SERVICE_NAME)
+
+  otl_span "#{SERVICE_NAME} start", {
+    'stack.name': ENV['STACK_NAME'],
+    'stack.service.name': ENV['STACK_SERVICE_NAME'],
+    'org.opencontainers.image.title': ENV['ORG_OPENCONTAINERS_IMAGE_TITLE'],
+    'org.opencontainers.image.url':  ENV['ORG_OPENCONTAINERS_IMAGE_URL'],
+    'org.opencontainers.image.source': ENV['ORG_OPENCONTAINERS_IMAGE_SOURCE'],
+    'org.opencontainers.image.created': ENV['ORG_OPENCONTAINERS_IMAGE_CREATED'],
+    'com.gitlab.ci.commt.timestamp': ENV['COM_GITLAB_CI_COMMIT_TIMESTAMP'],
+    'com.gitlab.ci.tag': ENV['COM_GITLAB_CI_TAG'],
+    RACK_ENV: ENV['RACK_ENV'],
+    NODE_ENV: ENV['NODE_ENV'],
+    SERVER_ENV: ENV['SERVER_ENV'],
+  } do |span|
+
+    span.add_event("not-working in kibana APM", attributes:{
+      event: 'Success',
+      message: 'Get data from elastic Success'
+    }.transform_keys(&:to_s) )
+    # span.status = OpenTelemetry::Trace::Status.error("error message here!")
+  end
+
+  app.use OTELTraceInfo
+end
+
+if defined? Sequel and OTEL_ENABLED
+  class Sequel::Database
+    alias old_test_connection test_connection
+
+    def test_connection(...)
+      OpenTelemetry::Common::Utilities.untraced do
+        old_test_connection(...)
+      end
+    end
+
+    alias old_valid_connection? valid_connection?
+    def valid_connection?(...)
+      OpenTelemetry::Common::Utilities.untraced do
+        old_valid_connection?(...)
+      end
+    end
+  end
+end
+
+def otl_span(name, attributes = {})
+  # span_ = OpenTelemetry::Trace.current_span
+  return yield(nil) unless OTEL_ENABLED
+
+  return yield(nil) unless $tracer_
+  $tracer_&.in_span(name, attributes: flatten_hash(attributes.transform_keys(&:to_s).transform_values{_1 || 'n/a'}) ) do |span|
+    yield span
+  end
+end
+
+def otl_current_span
+  return unless OTEL_ENABLED
+  yield OpenTelemetry::Trace.current_span
+end
+
+def otl_def(name)
+  original_method = self.respond_to?(:instance_method) ? instance_method(name) : method(name)
+  self.respond_to?(:remove_method) ? remove_method(name) : Object.send(:remove_method, name)
+  original_method = original_method.respond_to?(:unbind) ? original_method.unbind : original_method
+
+  define_method(name) do |*args, **kwargs, &block|
+    klass = self.respond_to?(:class_name) ? self.class_name : (self.respond_to?(:name) ? self.name : 'main')
+    otl_span("method: #{klass}.#{name}", {args: args.to_s, kwargs: kwargs.to_s}) do |span|
+      original_method.bind(self).call(*args, **kwargs, &block)
+    end
+  end
+end
+
+if defined?  OpenTelemetry::Instrumentation::Rack::Middlewares
+  OpenTelemetry::Instrumentation::Rack::Middlewares::TracerMiddleware.config[:url_quantization] = ->(path, env) {
+    "HTTP #{env['REQUEST_METHOD']} #{path}"
+  }
+end
+
+if OTEL_ENABLED
+  class OpenTelemetry::SDK::Trace::Span
+    alias add_attributes_old add_attributes
+
+    def add_attributes(attributes)
+      add_attributes_old flatten_hash attributes
+                           .transform_keys(&:to_s)
+                           .transform_values{ _1 || 'n/a' }
+    end
+  end
+end
+
+if defined? Safrano::Request and OTEL_ENABLED
+  require 'odata/error'
+
+  class Safrano::Request
+    def process
+      begin
+        @response = Safrano::Response.new
+        before.tap_error { |err| dispatch_error(err) }
+              .tap_valid { |_res| dispatch }
+
+      rescue Sequel::Error => e
+        OpenTelemetry::Trace.current_span.tap do |span|
+          span.record_exception(e)
+          span.status = OpenTelemetry::Trace::Status.error("Unhandled exception of type: #{e.class}")
+        end
+        dispatch_error(Safrano::SequelExceptionError.new(e))
+      end
+      @response.finish
+    end
+  end
+end
+
+

data/lib/stack-service-base/rack_helpers.rb

@@ -0,0 +1,185 @@
+module RackHelpers
+  def Rack.middleware_klass(&block)
+    Class.new do
+      define_method(:initialize) do |app, *opts, &block2|; @app = app; @opts = opts; @block = block2 || block end
+      def call(env) = @block.call env, @app, @opts
+    end
+  end
+
+  def Rack.define_middleware(name, &block)
+    Object.const_set name, Rack.middleware_klass(&block)
+  end
+
+  Rack.define_middleware :Authentication do |env, app|
+    token = env['HTTP_AUTHORIZATION'][/Bearer (.*)/, 1] rescue nil # Authorization: Bearer token
+    token ||= env['HTTP_AUTH'][/Bearer (.*)/, 1] rescue nil # AUTH: Bearer token
+    token ||= Rack::Request.new(env).cookies['token']
+    token_h = JWT.decode token, '', false, algorithm: 'RS256' rescue nil
+    token_h ||= [{}]
+
+    if defined? OpenTelemetry::Trace
+      OpenTelemetry::Trace.current_span.add_attributes'TOKEN' => token_h[0].to_json,
+                                                      'username' => (token_h[0]['username'] || '')
+    end
+    Async::Task.current.define_singleton_method :token, &-> { token_h[0] }
+
+    app.call env
+  end
+
+  # TODO:
+  #  - Only required for cross-thread context transfer
+  #
+  # Rack.define_middleware :AsyncDBConnectionOT do |env, app|
+  #   context_ = OpenTelemetry::Context.current
+  #   OpenTelemetry::Context.with_current(context_) do
+  #     OpenTelemetry::Trace.with_span(OpenTelemetry::Trace.current_span) do
+  #       app.call env
+  #     end
+  #   end
+  # end
+
+  # Rack.define_middleware :SwaggerUI do |env, app, opts|
+  #   # url = opts[:swagger]
+  #   @static ||= Rack::Static.new app, urls: [''], root: "#{__dir__}/../swagger_ui/", index: 'index.html', cascade: true
+  #   env['REQUEST_METHOD'] == 'GET' ? @static.call(env) : app.call(env)
+  # end
+
+  #
+
+  Rack.define_middleware :OTELTraceInfo do |env, app, opts|
+    status, headers, body = app.call env
+    if status.to_i >= 500
+      otl_current_span{
+        span_context = OpenTelemetry::Trace.current_span.context
+        trace_id = span_context.trace_id.unpack1('H*')
+
+        begin
+          bj = JSON.parse(body.join)
+          bj[:trace_id] = trace_id
+          body = [bj.to_json]
+        rescue =>e
+          body = [body.join + "\ntrace_id: #{trace_id}"]
+        end
+      }
+    end
+
+    [status, headers, body]
+  end
+
+  Rack.define_middleware :NoCache do |env, app, opts|
+    status, headers, body = app.call env
+    headers['Cache-Control'] = 'private,max-age=0,must-revalidate,no-store'
+    [status, headers, body]
+  end
+
+  # PATCH: for the Grape
+  class Rack::Lint::Wrapper::InputWrapper
+    def rewind = @input.rewind
+  end if defined? Rack::Lint::Wrapper::InputWrapper
+
+  class Rack::Lint
+    def call(env = nil) = @app.call(env)
+  end if defined? Rack::Lint
+
+  class Rack::CommonLogger
+    def log(env, status, header, began_at) = ()
+  end
+  # require 'rack/request'
+  # # sinatra was resolved to 3.0.2, which depends on
+  # #   rack (~> 2.2, >= 2.2.4)
+  # # /home/user/.rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/rack-2.2.4/lib/rack/request.rb
+  # module Rack::Request::Helpers
+  #   alias old_post POST
+  #   def POST = get_header(Rack::RACK_INPUT).empty? ? {} : old_post
+  # end
+
+  Rack.define_middleware :HeadersLogger do |env, app, opts|
+    LOGGER.info env.select { _1 =~ /HTTP/ }.transform_keys { _1.gsub 'HTTP_', '' }
+    status, headers, body =app.call env
+
+    if status.to_i / 100 == 5
+      _body = body.to_s # each(&:to_s).join
+      LOGGER.error [status, headers, _body]
+      OpenTelemetry::Trace.current_span.tap do |span|
+        event_attributes = { 'exception.type' => "HTTP #{status.to_i}", 'exception.message' => _body, 'exception.stacktrace' => '' }
+        span.add_event('exception', attributes: event_attributes)
+        span.status = OpenTelemetry::Trace::Status.error("Request error: #{status.to_i}")
+      end
+    end
+
+    LOGGER.info headers
+    [status, headers, body]
+  end
+
+  Rack.define_middleware :RequestProfile do |env, app, opts|
+    start = Time.now
+    LOGGER.debug "start:#{start}"
+    status, headers, body = app.call env
+    LOGGER.debug "#{Time.now - start} sec - end (fiber id: #{Fiber.current.__id__}, async task: #{Async::Task.current})"
+    headers['x-runtime'] = "#{Time.now - start}"
+    # if headers['Content-Type'] =~ /html/
+    #   headers['Set-Cookie'] = "Runtime=#{Time.now - start} sec;expires=Sat, 01-Jan-3000 00:00:00 GMT;path=/;"
+    # end
+    [status, headers, body]
+  end
+
+  class << self
+    def rack_setup(app)
+      # PATCH: for the Grape Swagger
+      # https://github.com/ruby-grape/grape-swagger/pull/905
+      # https://github.com/ruby-grape/grape-swagger/issues/904
+      GrapeSwagger::DocMethods::ParseParams.instance_eval do
+        def parse_enum_or_range_values(values)
+          case values
+          when Proc
+            parse_enum_or_range_values(values.call) if values.parameters.empty?
+          when Range
+            parse_range_values(values) # if values.first.is_a?(Integer) TODO
+          when Array
+            { enum: values }
+          else
+            { enum: [values] } if values
+          end
+        end
+      end if defined? GrapeSwagger::DocMethods::ParseParams
+
+      app.use Rack.middleware_klass do |env, app|
+        # env['REQUEST_PATH'] == '/healthcheck' ? [200, {}, ['Healthy']] : app.call(env)
+        env['PATH_INFO'] == '/healthcheck' ? [200, {'Content-Type' =>'application/json'}, [{ Status: 'Healthy' }.to_json ]] : app.call(env)
+      end
+
+      if defined? OpenTelemetry::Instrumentation::Rack::Middlewares::TracerMiddleware
+        use OpenTelemetry::Instrumentation::Rack::Middlewares::TracerMiddleware
+      end
+      app.use Rack::Deflater
+      app.use OTELTraceInfo
+
+      unless defined?(PERFORMANCE) && PERFORMANCE
+        app.use RequestProfile
+        app.use HeadersLogger
+
+        if defined? Rack::ODataCommonLogger
+          app.use Rack::ODataCommonLogger, LOGGER # or use Rack::CommonLogger, LOGGER
+        end
+      end
+
+      app.use Rack.middleware_klass do |env, app|
+        code, headers, body = env['REQUEST_METHOD'] == 'OPTIONS' ? [200, {}, []] : app.call(env)
+
+        # scheme = env['rack.url_scheme']
+        # referer = URI.parse env['HTTP_REFERER']
+        headers.merge!(
+          # 'Access-Control-Allow-Origin' => "#{referer.scheme}://#{referer.host}",
+          'Access-Control-Allow-Origin' => '*',
+          'Access-Control-Allow-Methods' => 'GET, PUT, POST, DELETE, HEAD, OPTIONS',
+          'Access-Control-Allow-Headers' => '*',
+          'Access-Control-Allow-Credentials' => 'true')
+        [code, headers, body]
+      end
+
+      # unless @run
+      #   run ->(_env) { [200, {'Content-Type' => 'text/plain'}, ['OK!?']] }
+      # end
+    end
+  end
+end

data/lib/stack-service-base.rb

@@ -1,3 +1,7 @@
+require 'stack-service-base/logging'
+require 'stack-service-base/rack_helpers'
+require 'stack-service-base/open_telemetry'
+
 module StackServiceBase
   class << self
     def rack_setup app
@@ -6,6 +10,7 @@ module StackServiceBase
       return unless app.respond_to? :use
 
       app.instance_eval do
+        RackHelpers.rack_setup app
         if ENV.fetch('PROMETHEUS_METRICS_EXPORT', 'true') == 'true'
           require 'stack-service-base/prometheus'
 
@@ -13,6 +18,11 @@ module StackServiceBase
           use Prometheus::Middleware::Collector
           use Prometheus::Middleware::Exporter
         end
+
+        if OTEL_ENABLED
+          otel_initialize app
+        end
+
       end
     end
   end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module StackServiceBase
   class Base
-    VERSION = '0.0.3'
+    VERSION = '0.0.5'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stack-service-base
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - ''
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prometheus-client
@@ -24,6 +24,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  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: opentelemetry-exporter-otlp
+  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: opentelemetry-instrumentation-all
+  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -115,8 +157,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/stack-service-base.rb
+- lib/stack-service-base/logging.rb
+- lib/stack-service-base/open_telemetry.rb
 - lib/stack-service-base/prometheus.rb
 - lib/stack-service-base/prometheus_parser.rb
+- lib/stack-service-base/rack_helpers.rb
 - lib/version.rb
 homepage:
 licenses: []