kirei 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 788221745d889864fe2ec7075cce289f6d44361dece7711fbe91ac24c16f693b
-  data.tar.gz: e03e3cf0c4c6db69bc0106107ccb002b8f472ba077ef457d88a84b92b188371f
+  metadata.gz: c1adc30a0abdfee8e565869c726e247ab07f3ab1cd535c2d7874182f501962a9
+  data.tar.gz: 533abff887e8aca8eda259ad66679b76b7d25d4236966a80fcf32dfafe18dcd2
 SHA512:
-  metadata.gz: 30bef2a1458e1aeeebd774d577df1dc231b0cfa46fb7483b076b69ac05de1529527442599dca18bb278fec42e1a17888eee849feb1b3f81dd502fd92284dd879
-  data.tar.gz: 181df5735f94c222fc29e9bb3c18aa33340995925a324a18a0bb28e1001eaeaee24f8c7442cc5852adf31ae7e5e7a707743441e1c64a585e27039e7b50ba96da
+  metadata.gz: ed22516b55aa7677b85dbf09e1f6f88822646574897e55831318eead12759f275e36394076be292be54d02f08223f78e827da3990d82871bcef6bd8d98a6f26c
+  data.tar.gz: 6aeb8fcc2cdf887da4824e1075c935f186f67d4639e01d6b099341a60e6c9ae7b6ce7ed30ad81ab1a40583152cf7006f4205c78d10b6aa775f45c345a53ff3f0

data/README.md

@@ -13,7 +13,7 @@ TL;DR:
 * **zero magic**
 * **strict typing**
 * **very few low level dependencies**
-* ultra low memory footprint
+* low memory footprint
 * high performance
 * simple to understand
 

data/lib/cli/commands/new_app/files/rakefile.rb

@@ -15,6 +15,9 @@ module Cli
               # frozen_string_literal: true
 
               require "rake"
+              require_relative "app"
+
+              Dir.glob("#{Kirei::GEM_ROOT}/lib/tasks/**/*.rake").each { import(_1) }
 
               Dir.glob("lib/tasks/**/*.rake").each { import(_1) }
 

data/lib/kirei/model/class_methods.rb

@@ -85,12 +85,40 @@ module Kirei
         return unless App.config.db_extensions.include?(:pg_json)
 
         attributes.each_pair do |key, value|
-          next unless value.is_a?(Hash) || value.is_a?(Array)
-
-          attributes[key] = T.unsafe(Sequel).pg_jsonb_wrap(value)
+          if vector_column?(key.to_s)
+            attributes[key] = cast_to_vector(value)
+          elsif value.is_a?(Hash) || value.is_a?(Array)
+            attributes[key] = T.unsafe(Sequel).pg_jsonb_wrap(value)
+          end
         end
       end
 
+      #
+      # install the gem "pgvector" if you need to use vector columns
+      # also add `:pgvector` to the `App.config.db_extensions` array
+      # and enable the vector extension on the database.
+      #
+      sig { params(column_name: String).returns(T::Boolean) }
+      def vector_column?(column_name)
+        _col_name, col_info = T.let(
+          db.schema(table_name.to_sym).find { _1[0] == column_name.to_sym },
+          [Symbol, T::Hash[Symbol, T.untyped]],
+        )
+        col_info.fetch(:db_type).match?(/vector\(\d+\)/)
+      end
+
+      # New method to cast an array to a vector
+      sig { params(value: T.any(T::Array[Numeric], Sequel::SQL::Expression)).returns(Sequel::SQL::Expression) }
+      def cast_to_vector(value)
+        return value if value.is_a?(Sequel::SQL::Expression) || value.is_a?(Sequel::SQL::PlaceholderLiteralString)
+
+        Kernel.raise("'pg_array' extension is not enabled") unless db.extension(:pg_array)
+
+        pg_array = T.unsafe(Sequel).pg_array(value)
+
+        Sequel.lit("?::vector", pg_array)
+      end
+
       sig do
         override.params(
           hash: T::Hash[Symbol, T.untyped],

data/lib/kirei/routing/base.rb

@@ -8,6 +8,8 @@ module Kirei
     class Base
       extend T::Sig
 
+      NOT_FOUND = T.let([404, {}, ["Not Found"]], RackResponseType) # rubocop:disable Style/MutableConstant
+
       sig { params(params: T::Hash[String, T.untyped]).void }
       def initialize(params: {})
         @router = T.let(Router.instance, Router)
@@ -23,6 +25,7 @@ module Kirei
       sig { params(env: RackEnvType).returns(RackResponseType) }
       def call(env)
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        status = 500 # we use it in the "ensure" block, so we need to define early (Sorbet doesn't like `status ||= 418`)
 
         http_verb = Verb.deserialize(env.fetch("REQUEST_METHOD"))
         req_path = T.cast(env.fetch("REQUEST_PATH"), String)
@@ -33,7 +36,7 @@ module Kirei
         #
 
         route = router.get(http_verb, req_path)
-        return [404, {}, ["Not Found"]] if route.nil?
+        return NOT_FOUND if route.nil?
 
         params = case route.verb
                  when Verb::GET
@@ -66,7 +69,13 @@ module Kirei
         Kirei::Logging::Logger.call(
           level: Kirei::Logging::Level::INFO,
           label: "Request Started",
-          meta: params,
+          meta: {
+            "http.method" => route.verb.serialize,
+            "http.route" => route.path,
+            "http.host" => env.fetch("HTTP_HOST"),
+            "http.request_params" => params,
+            "http.client_ip" => env.fetch("CF-Connecting-IP", env.fetch("REMOTE_ADDR")),
+          },
         )
 
         statsd_timing_tags = {
@@ -101,7 +110,7 @@ module Kirei
           ::StatsD.measure("request", latency_in_ms, tags: statsd_timing_tags)
 
           Kirei::Logging::Logger.call(
-            level: Kirei::Logging::Level::INFO,
+            level: status >= 500 ? Kirei::Logging::Level::ERROR : Kirei::Logging::Level::INFO,
             label: "Request Finished",
             meta: { "response.body" => response_body, "response.latency_in_ms" => latency_in_ms },
           )

data/lib/kirei/routing/rack_env_type.rb

@@ -13,9 +13,9 @@ module Kirei
           String,
           Numeric,
           TCPSocket,
-          Puma::Client,
+          ::Puma::Client,
           StringIO,
-          Puma::Configuration,
+          ::Puma::Configuration,
         )
       ]
     end

data/lib/kirei/services/runner.rb

@@ -10,12 +10,12 @@ module Kirei
       sig do
         type_parameters(:T)
           .params(
-            class_name: String,
+            class_name: T.untyped, # @TODO(lud, 17.08.2024): replace all non-word characters with `.`?
             log_tags: T::Hash[String, T.untyped],
-            _: T.proc.returns(T.type_parameter(:T)),
+            block: T.proc.returns(T.type_parameter(:T)),
           ).returns(T.type_parameter(:T))
       end
-      def self.call(class_name, log_tags: {}, &_)
+      def self.call(class_name, log_tags: {}, &block)
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
         service = yield
 
@@ -24,23 +24,43 @@ module Kirei
         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
+        result = service_result(service)
 
         metric_tags = Logging::Metric.inject_defaults({ "service.result" => result })
         ::StatsD.measure(class_name, latency_in_ms, tags: metric_tags)
 
         logtags = {
-          "service.name" => class_name,
+          "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)
+
+        Logging::Logger.call(level: log_level(result), 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
+
+      sig { params(service: T.untyped).returns(String) }
+      def self.service_result(service)
+        case service
+        when Services::Result
+          service.success? ? "success" : "failure"
+        else
+          "unknown"
+        end
+      end
+
+      sig { params(result: String).returns(Logging::Level) }
+      private_class_method def self.log_level(result)
+        return Logging::Level::INFO if result == "success"
+        return Logging::Level::WARN if result == "failure"
+
+        Logging::Level::UNKNOWN
       end
     end
   end

data/lib/kirei/version.rb

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-19 00:00:00.000000000 Z
+date: 2024-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -203,6 +203,7 @@ files:
 - 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