rage-rb 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bb19c01aee898bea43a41450feeb655f94bde8277a4f9c18cab6b9d1accbb47
-  data.tar.gz: fe4806d8a2bfbb71496a720371cc8416b5283c9b8284c1a72ec46384ee234348
+  metadata.gz: fd10469efc73f6134f72f79fe21871238b8860e958c085499c47b312adf91764
+  data.tar.gz: 34990a4885df4a4acd55fcbabf8d3a67e57e0609db406ee55d5f71cab0655ffb
 SHA512:
-  metadata.gz: 43d06881f297512724588c06637a29eefcb8308fc1c086a09b013c4291d4ca58cf7b2ab482b1c1276a3e4a88544a71e95289268cc896d479cb92135f31555bf8
-  data.tar.gz: 9af4f8816208451c18ff3b31d7d5a7e230561af93753d1ee0f8177f515b92f3dd2c47007b7f65be823ceeb69b6338683a05c57eb1a13e17cfe769b87e4ef2540
+  metadata.gz: bc28afd194f122bf436c215cb6d88dfe3d923874f4e07c3c1db5dd3f33a4676354731fad3f6ffc29326423086b59dbb0d1860ecb5cb71cf4c7f0412a252af16f
+  data.tar.gz: 58cd0cea6daba63d67f9285d3b616980d2e69c778620c54b14c7c5cb1eccf093bfbc0644dec081c325d4cdc5f6c032b7f399ccb8ea5b052c1da401dcde08ed6e

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [1.1.0] - 2024-03-25
+
+### Changed
+
+- Change the way controller names are logged (#72).
+- Use formatters in console (#71).
+
+### Fixed
+
+- Fix Fiber.await behavior in RSpec (#70).
+
 ## [1.0.0] - 2024-03-13
 
 ### Added

data/README.md

@@ -53,8 +53,12 @@ Check out in-depth API docs for more information:
 - [Fiber API](https://rage-rb.pages.dev/Fiber)
 - [Logger API](https://rage-rb.pages.dev/Rage/Logger)
 - [Configuration API](https://rage-rb.pages.dev/Rage/Configuration)
+- [CORS middleware](https://rage-rb.pages.dev/Rage/Cors)
 
-Also, see the [changelog](https://github.com/rage-rb/rage/blob/master/CHANGELOG.md) and [upcoming-releases](https://github.com/rage-rb/rage#upcoming-releases) for currently supported and planned features.
+Also, see the following integration guides:
+
+- [Rails integration](https://github.com/rage-rb/rage/wiki/Rails-integration)
+- [RSpec integration](https://github.com/rage-rb/rage/wiki/RSpec-integration)
 
 ### Example
 

data/lib/rage/all.rb

@@ -18,6 +18,7 @@ require_relative "router/constrainer"
 require_relative "router/dsl"
 require_relative "router/handler_storage"
 require_relative "router/node"
+require_relative "router/util"
 
 require_relative "controller/api"
 

data/lib/rage/configuration.rb

@@ -19,7 +19,7 @@
 #
 # • _config.middleware.use_
 #
-# > Adds a middleware to the top of the middleware stack. **This is the preferred way of adding a middleware.**
+# > Adds a middleware to the top of the middleware stack. **This is the recommended way of adding a middleware.**
 # > ```
 # config.middleware.use Rack::Cors do
 #   allow do
@@ -166,7 +166,7 @@ class Rage::Configuration
 
   # @private
   class Internal
-    attr_accessor :rails_mode, :rails_console
+    attr_accessor :rails_mode
 
     def inspect
       "#<#{self.class.name}>"

data/lib/rage/fiber.rb

@@ -1,5 +1,44 @@
 # frozen_string_literal: true
 
+##
+# Rage provides a simple and efficient API to wait on several instances of IO at the same time - {Fiber.await}.
+# 
+# Let's say we have the following controller:
+# ```ruby
+# class UsersController < RageController::API
+#   def show
+#     user = Net::HTTP.get(URI("http://users.service/users/#{params[:id]}"))
+#     bookings = Net::HTTP.get(URI("http://bookings.service/bookings?user_id=#{params[:id]}"))
+#     render json: { user: user, bookings: bookings }
+#   end
+# end
+# ```
+# This code will fire two consecutive HTTP requests. If each request takes 1 second to execute, the total execution time will be 2 seconds.<br>
+# With {Fiber.await}, we can significantly decrease the overall execution time by changing the code to fire the requests concurrently.
+#
+# To do this, we will need to:
+#
+# 1. Wrap every request in a separate fiber using {Fiber.schedule};
+# 2. Pass newly created fibers into {Fiber.await};
+#
+# ```ruby
+# class UsersController < RageController::API
+#   def show
+#     user, bookings = Fiber.await([
+#       Fiber.schedule { Net::HTTP.get(URI("http://users.service/users/#{params[:id]}")) },
+#       Fiber.schedule { Net::HTTP.get(URI("http://bookings.service/bookings?user_id=#{params[:id]}")) }
+#     ])
+#
+#     render json: { user: user, bookings: bookings }
+#   end
+# end
+# ```
+# With this change, if each request takes 1 second to execute, the total execution time will still be 1 second.
+# 
+# ## Creating fibers
+# Many developers see fibers as "lightweight threads" that should be used in conjunction with fiber pools, the same way we use thread pools for threads.<br>
+# Instead, it makes sense to think of fibers as regular Ruby objects. We don't use a pool of arrays when we need to create an array - we create a new object and let Ruby and the GC do their job.<br>
+# Same applies to fibers. Feel free to create as many fibers as you need on demand.
 class Fiber
   # @private
   AWAIT_ERROR_MESSAGE = "err"
@@ -58,7 +97,7 @@ class Fiber
   end
 
   # Wait on several fibers at the same time. Calling this method will automatically pause the current fiber, allowing the
-  #   server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
+  # server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
   #
   # @param fibers [Fiber, Array<Fiber>] one or several fibers to wait on. The fibers must be created using the `Fiber.schedule` call.
   # @example
@@ -109,4 +148,16 @@ class Fiber
       fibers.map!(&:__get_result)
     end
   end
+
+  # @!method self.schedule(&block)
+  #   Create a non-blocking fiber. Should mostly be used in conjunction with `Fiber.await`.
+  #   @example
+  #     Fiber.await([
+  #       Fiber.schedule { request_1 },
+  #       Fiber.schedule { request_2 }
+  #     ])
+  #   @example
+  #     fiber_1 = Fiber.schedule { request_1 }
+  #     fiber_2 = Fiber.schedule { request_2 }
+  #     Fiber.await([fiber_1, fiber_2])
 end

data/lib/rage/logger/json_formatter.rb

@@ -17,8 +17,8 @@ class Rage::JSONFormatter
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
-      if params
-        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{params[:controller]}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      if params && params[:controller]
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{Rage::Router::Util.path_to_name(params[:controller])}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
       else
         # no controller/action keys are written if there are no params
         return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"

data/lib/rage/logger/logger.rb

@@ -33,6 +33,23 @@ require "logger"
 # Rage.logger.info("Initializing")
 # Rage.logger.debug { "This is a " + potentially + " expensive operation" }
 # ```
+#
+# ## Using the logger
+# The recommended approach to logging with Rage is to make sure your code always logs the same message no matter what the input is.
+# You can achieve this by using the {with_context} and {tagged} methods. So, a code like this:
+# ```ruby
+# def process_purchase(user_id:, product_id:)
+#   Rage.logger.info "processing purchase with user_id = #{user_id}; product_id = #{product_id}"
+# end
+# ```
+# turns into this:
+# ```ruby
+# def process_purchase(user_id:, product_id:)
+#   Rage.logger.with_context(user_id: user_id, product_id: product_id) do
+#     Rage.logger.info "processing purchase"
+#   end
+# end
+# ```
 class Rage::Logger
   METHODS_MAP = {
     "debug" => Logger::DEBUG,
@@ -129,13 +146,6 @@ class Rage::Logger
             false
           end
         RUBY
-      elsif (Rage.config.internal.rails_mode ? Rage.config.internal.rails_console : defined?(IRB))
-        # the call was made from the console - don't use the formatter
-        <<-RUBY
-          def #{level_name}(msg = nil)
-            @logdev.write((msg || yield) + "\n")
-          end
-        RUBY
       elsif @formatter.class.name.start_with?("Rage::")
         # the call was made from within the application and a built-in formatter is used;
         # in such case we use the `gen_timestamp` method which is much faster than `Time.now.strftime`;

data/lib/rage/logger/text_formatter.rb

@@ -17,8 +17,8 @@ class Rage::TextFormatter
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
-      if params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
+      if params && params[:controller]
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{Rage::Router::Util.path_to_name(params[:controller])} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       else
         # no controller/action keys are written if there are no params
         return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"

data/lib/rage/rails.rb

@@ -11,12 +11,6 @@ Iodine.patch_rack
 # configure the framework
 Rage.config.internal.rails_mode = true
 
-# make sure log formatter is not used in console
-Rails.application.console do
-  Rage.config.internal.rails_console = true
-  Rage.logger.level = Rage.logger.level if Rage.logger # trigger redefining log methods
-end
-
 # patch ActiveRecord's connection pool
 if defined?(ActiveRecord)
   Rails.configuration.after_initialize do

data/lib/rage/router/backend.rb

@@ -67,7 +67,7 @@ class Rage::Router::Backend
     if handler.is_a?(String)
       raise "Invalid route handler format, expected to match the 'controller#action' pattern" unless handler =~ STRING_HANDLER_REGEXP
 
-      controller, action = to_controller_class($1), $2
+      controller, action = Rage::Router::Util.path_to_class($1), $2
       run_action_method_name = controller.__register_action(action.to_sym)
 
       meta[:controller] = $1
@@ -273,22 +273,4 @@ class Rage::Router::Backend
       end
     end
   end
-
-  def to_controller_class(str)
-    str.capitalize!
-    str.gsub!(/([\/_])([a-zA-Z0-9]+)/) do
-      if $1 == "/"
-        "::#{$2.capitalize}"
-      else
-        $2.capitalize
-      end
-    end
-
-    klass = "#{str}Controller"
-    if Object.const_defined?(klass)
-      Object.const_get(klass)
-    else
-      raise Rage::Errors::RouterError, "Routing error: could not find the #{klass} class"
-    end
-  end
 end

data/lib/rage/router/handler_storage.rb

@@ -48,10 +48,11 @@ class Rage::Router::HandlerStorage
   private
 
   def compile_create_params_object(param_keys, defaults, meta)
-    lines = [
-      ":controller => '#{meta[:controller]}'.freeze",
-      ":action => '#{meta[:action]}'.freeze"
-    ]
+    lines = if meta[:controller]
+      [":controller => '#{meta[:controller]}'.freeze", ":action => '#{meta[:action]}'.freeze"]
+    else
+      []
+    end
 
     param_keys.each_with_index do |key, i|
       lines << ":#{key} => param_values[#{i}]"

data/lib/rage/router/util.rb

@@ -0,0 +1,33 @@
+class Rage::Router::Util
+  class << self
+    # converts controller name in a path form into a class
+    # `api/v1/users` => `Api::V1::UsersController`
+    def path_to_class(str)
+      str = str.capitalize
+      str.gsub!(/([\/_])([a-zA-Z0-9]+)/) do
+        if $1 == "/"
+          "::#{$2.capitalize}"
+        else
+          $2.capitalize
+        end
+      end
+
+      klass = "#{str}Controller"
+      if Object.const_defined?(klass)
+        Object.const_get(klass)
+      else
+        raise Rage::Errors::RouterError, "Routing error: could not find the #{klass} class"
+      end
+    end
+
+    @@names_map = {}
+
+    # converts controller name in a path form into a string representation of a class
+    # `api/v1/users` => `"Api::V1::UsersController"`
+    def path_to_name(str)
+      @@names_map[str] || begin
+        @@names_map[str] = path_to_class(str).name
+      end
+    end
+  end
+end

data/lib/rage/rspec.rb

@@ -26,8 +26,8 @@ class Fiber
     fiber
   end
 
-  def self.await(_)
-    # no-op
+  def self.await(fibers)
+    Array(fibers).map(&:__get_result)
   end
 end
 

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-13 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -126,6 +126,7 @@ files:
 - lib/rage/router/handler_storage.rb
 - lib/rage/router/node.rb
 - lib/rage/router/strategies/host.rb
+- lib/rage/router/util.rb
 - lib/rage/rspec.rb
 - lib/rage/setup.rb
 - lib/rage/sidekiq_session.rb