rage-rb 0.3.0 → 0.5.0

data/lib/rage/fiber_scheduler.rb

@@ -3,41 +3,50 @@
 require "resolv"
 
 class Rage::FiberScheduler
+  MAX_READ = 65536
+
   def initialize
     @root_fiber = Fiber.current
   end
 
   def io_wait(io, events, timeout = nil)
     f = Fiber.current
-    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { f.resume }
-    Fiber.yield
+    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { |err| f.resume(err) }
 
-    events
+    err = Fiber.yield
+    if err == Errno::ETIMEDOUT::Errno
+      0
+    else
+      events
+    end
   end
 
-  # TODO: this is more synchronous than asynchronous right now
   def io_read(io, buffer, length, offset = 0)
-    loop do
-      string = ::Iodine::Scheduler.read(io.fileno, length, offset)
+    length_to_read = if length == 0
+      buffer.size > MAX_READ ? MAX_READ : buffer.size
+    else
+      length
+    end
+
+    while true
+      string = ::Iodine::Scheduler.read(io.fileno, length_to_read, offset)
 
       if string.nil?
         return offset
       end
 
       if string.empty?
-        io_wait(io, IO::READABLE)
-        next
+        return -Errno::EAGAIN::Errno
       end
 
       buffer.set_string(string, offset)
-      offset += string.bytesize
 
       size = string.bytesize
-      break if size >= length
-      length -= size
-    end
+      offset += size
+      return offset if size < length_to_read || size >= buffer.size
 
-    offset
+      Fiber.pause
+    end
   end
 
   def io_write(io, buffer, length, offset = 0)
@@ -46,15 +55,11 @@ class Rage::FiberScheduler
 
     ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
 
-    buffer.size - offset
+    bytes_to_write - offset
   end
 
   def kernel_sleep(duration = nil)
-    if duration
-      f = Fiber.current
-      ::Iodine.run_after((duration * 1000).to_i) { f.resume } 
-      Fiber.yield
-    end
+    block(nil, duration || 0)
   end
 
   # TODO: GC works a little strange with this closure;
@@ -75,13 +80,22 @@ class Rage::FiberScheduler
     Resolv.getaddresses(hostname)
   end
 
-  def block(blocker, timeout = nil)
-    f = Fiber.current
-    ::Iodine.subscribe("unblock:#{f.object_id}") do
-      ::Iodine.defer { ::Iodine.unsubscribe("unblock:#{f.object_id}") }
-      f.resume
+  def block(_blocker, timeout = nil)
+    f, fulfilled, channel = Fiber.current, false, "unblock:#{Fiber.current.object_id}"
+
+    resume_fiber_block = proc do
+      unless fulfilled
+        fulfilled = true
+        ::Iodine.defer { ::Iodine.unsubscribe(channel) }
+        f.resume
+      end
     end
-    # TODO support timeout
+
+    ::Iodine.subscribe(channel, &resume_fiber_block)
+    if timeout
+      ::Iodine.run_after((timeout * 1000).to_i, &resume_fiber_block)
+    end
+
     Fiber.yield
   end
 
@@ -90,15 +104,28 @@ class Rage::FiberScheduler
   end
 
   def fiber(&block)
-    f = Fiber.current
-    inner_schedule = f != @root_fiber
+    parent = Fiber.current
 
-    fiber = Fiber.new(blocking: false) do
-      Fiber.current.__set_result(block.call)
-    ensure
-      # send a message for `Fiber.await` to work
-      Iodine.publish("await:#{f.object_id}", "") if inner_schedule
+    fiber = if parent == @root_fiber
+      # the fiber to wrap a request in
+      Fiber.new(blocking: false) do
+        Fiber.current.__set_result(block.call)
+      end
+    else
+      # the fiber was created in the user code
+      logger = Thread.current[:rage_logger]
+
+      Fiber.new(blocking: false) do
+        Thread.current[:rage_logger] = logger
+        Fiber.current.__set_result(block.call)
+        # send a message for `Fiber.await` to work
+        Iodine.publish("await:#{parent.object_id}", "") if parent.alive?
+      rescue Exception => e
+        Fiber.current.__set_err(e)
+        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE) if parent.alive?
+      end
     end
+
     fiber.resume
 
     fiber

data/lib/rage/logger/logger.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "logger"
+
+##
+# All logs in `rage` consist of two parts: keys and tags. A sample log entry might look like this:
+# ```
+# [fecbba0735355738] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info message=hello
+# ```
+# In the log entry above, `timestamp`, `pid`, `level`, and `message` are keys, while `fecbba0735355738` is a tag.
+# 
+# Use {tagged} to add custom tags to an entry:
+# ```ruby
+# Rage.logger.tagged("ApiCall") do
+#   perform_api_call
+#   Rage.logger.info "success"
+# end
+# # => [fecbba0735355738][ApiCall] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info message=success
+# ```
+#
+# {with_context} can be used to add custom keys:
+# ```ruby
+# cache_key = "mykey"
+# Rage.logger.with_context(cache_key: cache_key) do
+#   get_from_cache(cache_key)
+#   Rage.logger.info "cache miss"
+# end
+# # => [fecbba0735355738] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info cache_key=mykey message=cache miss
+# ```
+#
+# `Rage::Logger` also implements the interface of Ruby's native {https://ruby-doc.org/3.2.2/stdlibs/logger/Logger.html Logger}:
+# ```ruby
+# Rage.logger.info("Initializing")
+# Rage.logger.debug { "This is a " + potentially + " expensive operation" }
+# ```
+class Rage::Logger
+  METHODS_MAP = {
+    "debug" => Logger::DEBUG,
+    "info" => Logger::INFO,
+    "warn" => Logger::WARN,
+    "error" => Logger::ERROR,
+    "fatal" => Logger::FATAL,
+    "unknown" => Logger::UNKNOWN
+  }
+  private_constant :METHODS_MAP
+
+  attr_reader :level, :formatter
+
+  # Create a new logger.
+  #
+  # @param log [Object] a filename (`String`), IO object (typically `STDOUT`, `STDERR`, or an open file), `nil` (it writes nothing) or `File::NULL` (same as `nil`)
+  # @param level [Integer] logging severity threshold
+  # @param formatter [#call] logging formatter
+  # @param shift_age [Integer, String] number of old log files to keep, or frequency of rotation  (`"daily"`, `"weekly"` or `"monthly"`). Default value is `0`, which disables log file rotation
+  # @param shift_size [Integer] maximum log file size in bytes (only applies when `shift_age` is a positive Integer)
+  # @param shift_period_suffix [String] the log file suffix format for daily, weekly or monthly rotation
+  # @param binmode sets whether the logger writes in binary mode
+  def initialize(log, level: Logger::DEBUG, formatter: Rage::TextFormatter.new, shift_age: 0, shift_size: 104857600, shift_period_suffix: "%Y%m%d", binmode: false)
+    if log && log != File::NULL
+      @logdev = Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
+    end
+
+    @formatter = formatter
+    @level = level
+    define_log_methods
+  end
+
+  def level=(level)
+    @level = level
+    define_log_methods
+  end
+
+  def formatter=(formatter)
+    @formatter = formatter
+    define_log_methods
+  end
+
+  # Add custom keys to an entry.
+  #
+  # @param context [Hash] a hash of custom keys
+  # @example
+  #   Rage.logger.with_context(key: "mykey") do
+  #     Rage.logger.info "cache miss"
+  #   end
+  def with_context(context)
+    old_context = Thread.current[:rage_logger][:context]
+
+    if old_context.empty? # there's nothing in the context yet
+      Thread.current[:rage_logger][:context] = context
+    else # it's not the first `with_context` call in the chain
+      Thread.current[:rage_logger][:context] = old_context.merge(context)
+    end
+
+    yield(self)
+    true
+
+  ensure
+    Thread.current[:rage_logger][:context] = old_context
+  end
+
+  # Add a custom tag to an entry.
+  #
+  # @param tag [String] the tag to add to an entry
+  # @example
+  #   Rage.logger.tagged("ApiCall") do
+  #     Rage.logger.info "success"
+  #   end
+  def tagged(tag)
+    Thread.current[:rage_logger][:tags] << tag
+
+    yield(self)
+    true
+
+  ensure
+    Thread.current[:rage_logger][:tags].pop
+  end
+
+  alias_method :with_tag, :tagged
+
+  private
+
+  def define_log_methods
+    methods = METHODS_MAP.map do |level_name, level_val|
+      if @logdev.nil? || level_val < @level
+        # logging is disabled or the log level is higher than the current one
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            false
+          end
+        RUBY
+      elsif defined?(IRB)
+        # the call was made from IRB - 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`;
+        # it's not a standard approach however, so it's used with built-in formatters only
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            @logdev.write(
+              @formatter.call("#{level_name}".freeze, Iodine::Rack::Utils.gen_timestamp, nil, msg || yield)
+            )
+          end
+        RUBY
+      else
+        # the call was made from within the application and a custom formatter is used;
+        # stick to the standard approach of using one of the Log Level constants as sevetiry and `Time.now` as time
+        <<-RUBY
+          def #{level_name}(msg = nil)
+            @logdev.write(
+              @formatter.call(#{level_val}, Time.now, nil, msg || yield)
+            )
+          end
+        RUBY
+      end
+    end
+
+    self.class.class_eval(methods.join("\n"))
+  end
+end

data/lib/rage/logger/text_formatter.rb

@@ -0,0 +1,46 @@
+class Rage::TextFormatter
+  def initialize
+    @pid = Process.pid
+    Iodine.on_state(:on_start) do
+      @pid = Process.pid
+    end
+  end
+
+  def call(severity, timestamp, _, message)
+    logger = Thread.current[:rage_logger]
+    tags = logger[:tags]
+
+    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]} 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"]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+      end
+    end
+
+    if tags.length == 1
+      tags_msg = "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
+    elsif tags.length == 2
+      tags_msg = "[#{tags[0]}][#{tags[1]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
+    else
+      tags_msg = "[#{tags[0]}][#{tags[1]}]"
+      i = 2
+      while i < tags.length
+        tags_msg << "[#{tags[i]}]"
+        i += 1
+      end
+      tags_msg << " timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
+    end
+
+    context = logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "#{k}=#{v} " }
+    end
+
+    "#{tags_msg} #{context_msg}message=#{message}\n"
+  end
+end

data/lib/rage/params_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Rage::ParamsParser
+  def self.prepare(env, url_params)
+    has_body, query_string, content_type = env["IODINE_HAS_BODY"], env["QUERY_STRING"], env["CONTENT_TYPE"]
+
+    query_params = Iodine::Rack::Utils.parse_nested_query(query_string) if query_string != ""
+    unless has_body
+      if query_params
+        return query_params.merge!(url_params)
+      else
+        return url_params
+      end
+    end
+
+    request_params = if content_type.start_with?("application/json")
+      json_parse(env["rack.input"].read)
+    elsif content_type.start_with?("application/x-www-form-urlencoded")
+      Iodine::Rack::Utils.parse_urlencoded_nested_query(env["rack.input"].read)
+    else
+      Iodine::Rack::Utils.parse_multipart(env["rack.input"], content_type)
+    end
+
+    if request_params && !query_params
+      request_params.merge!(url_params)
+    elsif request_params && query_params
+      request_params.merge!(query_params, url_params)
+    else
+      url_params
+    end
+
+  rescue => e
+    raise Rage::Errors::BadRequest
+  end
+
+  if defined?(::FastJsonparser)
+    def self.json_parse(json)
+      FastJsonparser.parse(json, symbolize_keys: true)
+    end
+  else
+    def self.json_parse(json)
+      JSON.parse(json, symbolize_names: true)
+    end
+  end
+end

data/lib/rage/request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Rage::Request
+  # @private
+  def initialize(env)
+    @env = env
+  end
+
+  # Get the request headers.
+  # @example
+  #   request.headers["Content-Type"] # => "application/json"
+  #   request.headers["Connection"] # => "keep-alive"
+  def headers
+    @headers ||= Headers.new(@env)
+  end
+
+  # @private
+  class Headers
+    HTTP = "HTTP_"
+
+    def initialize(env)
+      @env = env
+    end
+
+    def [](requested_header)
+      if requested_header.start_with?(HTTP)
+        @env[requested_header]
+      else
+        (requested_header = requested_header.tr("-", "_")).upcase!
+
+        if "CONTENT_TYPE" == requested_header || "CONTENT_LENGTH" == requested_header
+          @env[requested_header]
+        else
+          @env["#{HTTP}#{requested_header}"]
+        end
+      end
+    end
+
+    def inspect
+      headers = @env.select { |k| k == "CONTENT_TYPE" || k == "CONTENT_LENGTH" || k.start_with?(HTTP) }
+      "#<#{self.class.name} @headers=#{headers.inspect}"
+    end
+  end # class Headers
+end

data/lib/rage/router/backend.rb

@@ -14,8 +14,36 @@ class Rage::Router::Backend
     @constrainer = Rage::Router::Constrainer.new({})
   end
 
-  def on(method, path, handler, constraints: {}, defaults: nil)
+  def mount(path, handler, methods)
+    raise "Mount handler should respond to `call`" unless handler.respond_to?(:call)
+
     raw_handler = handler
+    is_sidekiq = handler.respond_to?(:name) && handler.name == "Sidekiq::Web"
+
+    handler = ->(env, _params) do
+      env["SCRIPT_NAME"] = path
+      sub_path = env["PATH_INFO"].delete_prefix!(path)
+      env["PATH_INFO"] = "/" if sub_path == ""
+
+      if is_sidekiq
+        Rage::SidekiqSession.with_session(env) do
+          raw_handler.call(env)
+        end
+      else
+        raw_handler.call(env)
+      end
+
+    ensure
+      env["PATH_INFO"] = "#{env["SCRIPT_NAME"]}#{sub_path}"
+    end
+
+    methods.each do |method|
+      __on(method, path, handler, {}, {}, { raw_handler:, mount: true })
+      __on(method, "#{path}/*", handler, {}, {}, { raw_handler:, mount: true })
+    end
+  end
+
+  def on(method, path, handler, constraints: {}, defaults: nil)
     raise "Path could not be empty" if path&.empty?
 
     if match_index = (path =~ OPTIONAL_PARAM_REGEXP)
@@ -29,12 +57,17 @@ class Rage::Router::Backend
       return
     end
 
+    meta = { raw_handler: handler }
+
     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
       run_action_method_name = controller.__register_action(action.to_sym)
 
+      meta[:controller] = $1
+      meta[:action] = $2
+
       handler = eval("->(env, params) { #{controller}.new(env, params).#{run_action_method_name} }")
     else
       raise "Non-string route handler should respond to `call`" unless handler.respond_to?(:call)
@@ -45,7 +78,7 @@ class Rage::Router::Backend
       handler = ->(env, _params) { orig_handler.call(env) }
     end
 
-    __on(method, path, handler, raw_handler, constraints, defaults)
+    __on(method, path, handler, constraints, defaults, meta)
   end
 
   def lookup(env)
@@ -55,7 +88,7 @@ class Rage::Router::Backend
 
   private
 
-  def __on(method, path, handler, raw_handler, constraints, defaults)
+  def __on(method, path, handler, constraints, defaults, meta)
     @constrainer.validate_constraints(constraints)
     # Let the constrainer know if any constraints are being used now
     @constrainer.note_usage(constraints)
@@ -162,7 +195,7 @@ class Rage::Router::Backend
       end
     end
 
-    route = { method: method, path: path, pattern: pattern, params: params, constraints: constraints, handler: handler, raw_handler: raw_handler, defaults: defaults }
+    route = { method:, path:, pattern:, params:, constraints:, handler:, defaults:, meta: }
     @routes << route
     current_node.add_route(route, @constrainer)
   end