kirei 0.3.0 → 0.4.1

data/lib/kirei/services/runner.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Services
+    class Runner
+      extend T::Sig
+      extend T::Generic
+
+      sig do
+        type_parameters(:T)
+          .params(
+            class_name: T.untyped,
+            log_tags: T::Hash[String, T.untyped],
+            block: T.proc.returns(T.type_parameter(:T)),
+          ).returns(T.type_parameter(:T))
+      end
+      def self.call(class_name, log_tags: {}, &block)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        service = yield
+
+        service
+      ensure
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        latency_in_ms = stop - T.must(start)
+
+        result = case service
+                 when Services::Result
+                   service.success? ? "success" : "failure"
+                 else
+                   "unknown"
+        end
+
+        metric_tags = Logging::Metric.inject_defaults({ "service.result" => result })
+        ::StatsD.measure(class_name, latency_in_ms, tags: metric_tags)
+
+        logtags = {
+          "service.name" => class_name.to_s,
+          "service.latency_in_ms" => latency_in_ms,
+          "service.result" => result,
+          "service.source_location" => source_location(block),
+        }
+        logtags.merge!(log_tags)
+
+        Logging::Logger.call(level: Logging::Level::INFO, label: "Service Finished", meta: logtags)
+      end
+
+      sig { params(proc: T.proc.returns(T.untyped)).returns(String) }
+      private_class_method def self.source_location(proc)
+        proc.source_location.join(":").gsub(App.root.to_s, "")
+      end
+    end
+  end
+end

data/lib/kirei/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Kirei
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/kirei.rb

@@ -13,6 +13,7 @@ require "bundler/setup"
 
 # Second: load all gems (runtime dependencies only)
 require "logger"
+require "statsd-instrument"
 require "sorbet-runtime"
 require "oj"
 require "rack"
@@ -33,7 +34,7 @@ module Kirei
   # rubocop:disable Style/MutableConstant
   OJ_OPTIONS = T.let(
     {
-      mode: :compat, # required to dump hashes with symbol-keys
+      mode: :compat, # required to dump hashes with symbol-keys. @TODO(lud, 14.05.2024): drop this, and enforce String Keys?
       symbol_keys: false, # T::Struct.new works only with string-keys
     },
     T::Hash[Symbol, T.untyped],
@@ -67,4 +68,6 @@ loader.eager_load
 
 Kirei.configure(&:itself)
 
-Kirei::Logger.logger.info("Kirei (v#{Kirei::VERSION}) booted.")
+yjit_enabled = defined?(RubyVM::YJIT) ? RubyVM::YJIT.enabled? : false
+
+Kirei::Logging::Logger.logger.info("Kirei v#{Kirei::VERSION} booted; YJIT enabled: #{yjit_enabled}")

data/lib/tasks/routes.rake

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative("../kirei")
+
+namespace :kirei do
+  desc "Prints all available routes"
+  task :routes do
+    router = Kirei::Routing::Router.instance
+
+    longest_path = router.routes.keys.map(&:length).max
+
+    routes_by_controller = router.routes.values.group_by(&:controller)
+
+    puts "\n"
+
+    routes_by_controller.each do |controller, routes|
+      puts "#{controller}:"
+      routes.each do |route|
+        verb = route.verb.serialize.upcase.ljust(7 + 3) # 7 is the length of the longest verb
+        puts "#{verb} #{route.path.ljust(longest_path + 1)} => ##{route.action}"
+      end
+      puts "\n"
+    end
+  end
+end

data/sorbet/rbi/shims/ruby.rbi

@@ -0,0 +1,15 @@
+# typed: true
+
+#
+# The RubyVM module only exists on MRI. RubyVM is not defined in other Ruby implementations such as JRuby and TruffleRuby.
+#
+# The RubyVM module provides some access to MRI internals. This module is for very limited purposes, such as debugging, prototyping, and research. Normal users must not use it. This module is not portable between Ruby implementations.
+#
+class RubyVM
+  module YJIT
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    def self.enabled?; end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-13 00:00:00.000000000 Z
+date: 2024-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: statsd-instrument
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: tzinfo-data
   requirement: !ruby/object:Gem::Requirement
@@ -169,16 +183,29 @@ files:
 - lib/kirei/app.rb
 - lib/kirei/config.rb
 - lib/kirei/controller.rb
+- lib/kirei/errors/json_api_error.rb
+- lib/kirei/errors/json_api_error_source.rb
 - lib/kirei/helpers.rb
-- lib/kirei/logger.rb
+- lib/kirei/logging/level.rb
+- lib/kirei/logging/logger.rb
+- lib/kirei/logging/metric.rb
 - lib/kirei/model.rb
+- lib/kirei/model/base_class_interface.rb
+- lib/kirei/model/class_methods.rb
+- lib/kirei/model/human_id_generator.rb
 - lib/kirei/routing/base.rb
 - lib/kirei/routing/nilable_hooks_type.rb
 - lib/kirei/routing/rack_env_type.rb
 - lib/kirei/routing/rack_response_type.rb
+- lib/kirei/routing/route.rb
 - lib/kirei/routing/router.rb
+- lib/kirei/routing/verb.rb
+- lib/kirei/services/result.rb
+- lib/kirei/services/runner.rb
 - lib/kirei/version.rb
+- lib/tasks/routes.rake
 - sorbet/rbi/shims/base_model.rbi
+- sorbet/rbi/shims/ruby.rbi
 homepage: https://github.com/swiknaba/kirei
 licenses:
 - MIT

data/lib/kirei/logger.rb

@@ -1,196 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Kirei
-  # rubocop:disable Metrics
-
-  #
-  # Example Usage:
-  #
-  #    Kirei::Logger.call(
-  #      level: :info,
-  #      label: "Request started",
-  #      meta: {
-  #        key: "value",
-  #      },
-  #    )
-  #
-  # You can define a custom log transformer to transform the logline:
-  #
-  #    Kirei::App.config.log_transformer = Proc.new { _1 }
-  #
-  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei::App.config.sensitive_keys`.
-  # You can also build on top of the provided log transformer:
-  #
-  #   Kirei::App.config.log_transformer = Proc.new do |meta|
-  #      flattened_meta = Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta)
-  #      # Do something with the flattened meta
-  #      flattened_meta.map { _1.to_json }
-  #   end
-  #
-  # NOTE: The log transformer must return an array of strings to allow emitting multiple lines per log event.
-  #
-  class Logger
-    extend T::Sig
-
-    FILTERED = "[FILTERED]"
-
-    @instance = T.let(nil, T.nilable(Kirei::Logger))
-
-    sig { void }
-    def initialize
-      super
-      @queue = T.let(Thread::Queue.new, Thread::Queue)
-      @thread = T.let(start_logging_thread, Thread)
-    end
-
-    sig { returns(Kirei::Logger) }
-    def self.instance
-      @instance ||= new
-    end
-
-    sig { returns(::Logger) }
-    def self.logger
-      return @logger unless @logger.nil?
-
-      @logger = T.let(nil, T.nilable(::Logger))
-      @logger ||= ::Logger.new($stdout)
-
-      # we want the logline to be parseable to JSON
-      @logger.formatter = proc do |_severity, _datetime, _progname, msg|
-        "#{msg}\n"
-      end
-
-      @logger
-    end
-
-    sig do
-      params(
-        level: T.any(String, Symbol),
-        label: String,
-        meta: T::Hash[Symbol, T.untyped],
-      ).void
-    end
-    def self.call(level:, label:, meta: {})
-      return if ENV["LOGGER"] == "disabled"
-
-      instance.call(level: level, label: label, meta: meta)
-    end
-
-    sig do
-      params(
-        level: T.any(String, Symbol),
-        label: String,
-        meta: T::Hash[Symbol, T.untyped],
-      ).void
-    end
-    def call(level:, label:, meta: {})
-      Kirei::App.config.log_default_metadata.each_pair do |key, value|
-        meta[key] ||= value
-      end
-
-      #
-      # key names follow OpenTelemetry Semantic Conventions
-      # Source: https://opentelemetry.io/docs/concepts/semantic-conventions/
-      #
-      meta[:"service.instance.id"] ||= Thread.current[:request_id]
-      meta[:"service.name"] ||= Kirei::App.config.app_name
-
-      # The Ruby logger only accepts one string as the only argument
-      @queue << { level: level, label: label, meta: meta }
-    end
-
-    sig { returns(Thread) }
-    def start_logging_thread
-      Thread.new do
-        Kernel.loop do
-          log_data = T.let(@queue.pop, T::Hash[Symbol, T.untyped])
-          level = log_data.fetch(:level)
-          label = log_data.fetch(:label)
-          meta = T.let(log_data.fetch(:meta), T::Hash[Symbol, T.untyped])
-          meta[:"service.version"] ||= Kirei::App.version
-          meta[:timestamp] ||= Time.now.utc.iso8601
-          meta[:level] ||= level.to_s.upcase
-          meta[:label] ||= label
-
-          log_transformer = App.config.log_transformer
-
-          loglines = if log_transformer
-            log_transformer.call(meta)
-          else
-            [Oj.dump(
-              Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta),
-              Kirei::OJ_OPTIONS,
-            )]
-          end
-
-          loglines.each { Kirei::Logger.logger.error(_1) }
-        end
-      end
-    end
-
-    # rubocop:disable Naming/MethodParameterName
-    sig do
-      params(
-        k: Symbol,
-        v: String,
-      ).returns(String)
-    end
-    def self.mask(k, v)
-      return Kirei::Logger::FILTERED if App.config.sensitive_keys.any? { k.match?(_1) }
-
-      v
-    end
-    # rubocop:enable Naming/MethodParameterName
-
-    sig do
-      params(
-        hash: T::Hash[T.any(Symbol, String), T.untyped],
-        prefix: Symbol,
-      ).returns(T::Hash[Symbol, T.untyped])
-    end
-    def self.flatten_hash_and_mask_sensitive_values(hash, prefix = :'')
-      result = T.let({}, T::Hash[Symbol, T.untyped])
-      Kirei::Helpers.deep_symbolize_keys!(hash)
-      hash = T.cast(hash, T::Hash[Symbol, T.untyped])
-
-      hash.each do |key, value|
-        new_prefix = Kirei::Helpers.blank?(prefix) ? key : :"#{prefix}.#{key}"
-
-        case value
-        when Hash
-          # Some libraries have a custom Hash class that inhert from Hash, but act differently, e.g. OmniAuth::AuthHash.
-          # This results in `transform_keys` being available but without any effect.
-          value = value.to_h if value.class != Hash
-          result.merge!(flatten_hash_and_mask_sensitive_values(value.transform_keys(&:to_sym), new_prefix))
-        when Array
-          value.each_with_index do |element, index|
-            if element.is_a?(Hash) || element.is_a?(Array)
-              result.merge!(flatten_hash_and_mask_sensitive_values({ index => element }, new_prefix))
-            else
-              result[:"#{new_prefix}.#{index}"] = element.is_a?(String) ? mask(key, element) : element
-            end
-          end
-        when String then result[new_prefix] = mask(key, value)
-        when Numeric, FalseClass, TrueClass, NilClass then result[new_prefix] = value
-        else
-          if value.respond_to?(:serialize)
-            serialized_value = value.serialize
-            if serialized_value.is_a?(Hash)
-              result.merge!(
-                flatten_hash_and_mask_sensitive_values(serialized_value.transform_keys(&:to_sym), new_prefix),
-              )
-            else
-              result[new_prefix] = serialized_value&.to_s
-            end
-          else
-            result[new_prefix] = value&.to_s
-          end
-        end
-      end
-
-      result
-    end
-  end
-  # rubocop:enable Metrics
-end