pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/logger/formatter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Logger
+    class Formatter
+      attr_reader :output
+
+      def initialize(output)
+        @output = output
+      end
+
+      def call(event, **options)
+        event = yield if block_given?
+        format(event, **options)
+      end
+
+      def verbose!(value)
+        @verbose = value
+      end
+    end
+  end
+end

data/lib/pakyow/logger/formatters/human.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "pakyow/connection"
+require "pakyow/error"
+
+require "pakyow/logger/colorizer"
+require "pakyow/logger/formatter"
+require "pakyow/logger/timekeeper"
+
+require "pakyow/connection/statuses"
+
+module Pakyow
+  class Logger
+    module Formatters
+      # Formats log messages for humans.
+      #
+      # @example
+      #   19.00μs http.c730cb72 | GET / (for 127.0.0.1 at 2016-06-20 10:00:49 -0500)
+      #    1.97ms http.c730cb72 | hello 2016-06-20 10:00:49 -0500
+      #    3.78ms http.c730cb72 | 200 (OK)
+      #
+      # @api private
+      class Human < Formatter
+        private
+
+        def format(event, **options)
+          entry = String.new
+
+          case event
+          when Hash
+            if event.key?("logger") && event.key?("message")
+              format_logger_message(event, entry)
+            else
+              entry << event.to_s
+            end
+          else
+            entry << event.to_s
+          end
+
+          @output.call(Colorizer.colorize(entry, options[:severity]) << "\n")
+        end
+
+        def format_logger_message(logger_message, entry)
+          logger = logger_message["logger"]
+          message = logger_message["message"]
+
+          format_info(entry, id: logger.id, type: logger.type, elapsed: logger.elapsed)
+
+          case message
+          when Hash
+            if connection = message["prologue"]
+              format_prologue(connection, entry)
+            elsif connection = message["epilogue"]
+              format_epilogue(connection, entry)
+            elsif error = message["error"]
+              format_error(error, entry)
+            else
+              format_message(message, entry)
+            end
+          when Exception
+            format_error(message, entry)
+          else
+            format_message(message, entry)
+          end
+        end
+
+        def format_prologue(connection, entry)
+          entry << connection.request_method << " " << connection.path
+          entry << " (for " << connection.ip << " at " << connection.timestamp.to_s << ")"
+        end
+
+        def format_epilogue(connection, entry)
+          entry << connection.status.to_s << " (" << Connection::Statuses.describe(connection.status) << ")"
+        end
+
+        def format_info(entry, id:, type:, elapsed:)
+          entry << Timekeeper.format_elapsed_time(elapsed).rjust(8, " ")
+          entry << " " << type.to_s << "." << id << " | "
+        end
+
+        def format_message(message, entry)
+          message.to_s.each_line.with_index do |line, i|
+            if i == 0
+              entry << line.rstrip
+            else
+              entry << "\n                       | " << line.rstrip
+            end
+          end
+        end
+
+        def format_error(error, entry)
+          unless error.is_a?(Error)
+            error = Error.build(error)
+          end
+
+          format_message(Error::CLIFormatter.new(error), entry)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/logger/formatters/json.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+
+require "pakyow/logger"
+require "pakyow/logger/timekeeper"
+
+module Pakyow
+  class Logger
+    module Formatters
+      # Formats log messages as json.
+      #
+      # @example
+      #   {"severity":"info","timestamp":"2016-06-20 10:07:30 -0500","id":"c8af6a8b","type":"http","elapsed":"0.01ms","method":"GET","path":"/","ip":"127.0.0.1"}
+      #   {"severity":"info","timestamp":"2016-06-20 10:07:30 -0500","id":"c8af6a8b","type":"http","elapsed":"1.24ms","message":"hello 2016-06-20 10:07:30 -0500"}
+      #   {"severity":"info","timestamp":"2016-06-20 10:07:30 -0500","id":"c8af6a8b","type":"http","elapsed":"3.08ms","status":200}
+      #
+      # @api private
+      class JSON < Formatter
+        private
+
+        def format(event, **options)
+          entry = {
+            "severity" => options[:severity],
+            "timestamp" => Time.now
+          }
+
+          case event
+          when Hash
+            if event.key?("logger") && event.key?("message")
+              format_logger_message(event, entry)
+            else
+              entry.merge!(event)
+            end
+          else
+            entry["message"] = event.to_s
+          end
+
+          serialize(entry)
+        end
+
+        private
+
+        def format_logger_message(logger_message, entry)
+          logger = logger_message["logger"]
+          message = logger_message["message"]
+
+          format_entry(
+            entry, id: logger.id, type: logger.type, elapsed: logger.elapsed
+          )
+
+          case message
+          when Hash
+            if connection = message.delete("prologue")
+              format_prologue(connection, entry)
+            elsif connection = message.delete("epilogue")
+              format_epilogue(connection, entry)
+            elsif error = message.delete("error")
+              format_error(error, entry)
+            else
+              entry.update(message)
+            end
+          when Exception
+            format_error(message, entry)
+          else
+            entry["message"] = message.to_s
+          end
+        end
+
+        def format_prologue(connection, entry)
+          entry["method"] = connection.request_method
+          entry["uri"] = connection.path
+          entry["ip"] = connection.ip
+        end
+
+        def format_epilogue(connection, entry)
+          entry["status"] = connection.status
+        end
+
+        def format_error(error, entry)
+          entry["exception"] = error.class
+          entry["message"] = error.to_s
+          entry["backtrace"] = error.backtrace
+        end
+
+        def format_entry(entry, id:, type:, elapsed:)
+          entry["id"] = id
+          entry["type"] = type
+          entry["elapsed"] = Timekeeper.format_elapsed_time_in_milliseconds(elapsed)
+          entry
+        end
+
+        def serialize(entry)
+          @output.call(entry.to_json << "\n")
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/logger/formatters/logfmt.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "pakyow/logger/formatters/json"
+
+module Pakyow
+  class Logger
+    module Formatters
+      # Formats log messages as logfmt.
+      #
+      # @example
+      #   severity=INFO timestamp="2016-06-20 10:08:29 -0500" id=678cf582 type=http elapsed=0.01ms method=GET uri=/ ip=127.0.0.1
+      #   severity=INFO timestamp="2016-06-20 10:08:29 -0500" id=678cf582 type=http elapsed=1.56ms message="hello 2016-06-20 10:08:29 -0500"
+      #   severity=INFO timestamp="2016-06-20 10:08:29 -0500" id=678cf582 type=http elapsed=3.37ms status=200
+      #
+      # @api private
+      class Logfmt < Pakyow::Logger::Formatters::JSON
+        private
+
+        UNESCAPED_STRING = /\A[\w\.\-\+\%\,\:\;\/]*\z/i
+
+        def serialize(message)
+          first = true
+          message.each_pair do |key, value|
+            value = case value
+            when Array
+              value.join(",")
+            else
+              value.to_s
+            end
+
+            unless value.match?(UNESCAPED_STRING)
+              value = value.dump
+            end
+
+            unless first
+              @output.call(" ")
+            end
+
+            @output.call(key)
+            @output.call("=")
+            @output.call(value)
+            first = false
+          end
+
+          @output.call("\n")
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/logger/multiplexed.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Logger
+    class Multiplexed
+      attr_reader :destinations
+
+      def initialize(*destinations)
+        @destinations = destinations
+      end
+
+      def call(entry)
+        @destinations.each do |destination|
+          destination.call(entry)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/logger/thread_local.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "pakyow/support/deep_freeze"
+
+require "pakyow/logger"
+
+module Pakyow
+  class Logger
+    # Determines at log time what logger to use, based on a thread-local context.
+    #
+    class ThreadLocal
+      extend Support::DeepFreeze
+      unfreezable :default
+
+      extend Forwardable
+      def_delegators :target, *(Logger.instance_methods - Object.instance_methods)
+
+      def initialize(default_logger)
+        @default = default_logger
+      end
+
+      def target
+        Thread.current[:pakyow_logger] || @default
+      end
+    end
+  end
+end

data/lib/pakyow/logger/timekeeper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Logger
+    # Helpers for formatting elapsed time in logs.
+    #
+    module Timekeeper
+      # Accepts elapsed time and formats it to be more human-readable.
+      #
+      # @example
+      #   Pakyow::Logger::Timekeeper.format_elapsed_time(60)
+      #   => 1.00m
+      #
+      # @example
+      #   Pakyow::Logger::Timekeeper.format_elapsed_time(15)
+      #   => 15.00s
+      #
+      # @example
+      #   Pakyow::Logger::Timekeeper.format_elapsed_time(0.1)
+      #   => 100.00ms
+      #
+      # @example
+      #   Pakyow::Logger::Timekeeper.format_elapsed_time(0.00001)
+      #   => 10.00μs
+      #
+      # @param time [Fixnum, Float] the elapsed time (in seconds)
+      #
+      # @return [String] elapsed time, rounded to two decimal places
+      #   with the proper units
+      #
+      def self.format_elapsed_time(time)
+        if time >= 60
+          format_elapsed_time_in_minutes(time)
+        elsif time >= 1
+          format_elapsed_time_in_seconds(time)
+        elsif time >= 0.001
+          format_elapsed_time_in_milliseconds(time)
+        else
+          format_elapsed_time_in_microseconds(time)
+        end
+      end
+
+      def self.format_elapsed_time_in_minutes(time)
+        round_elapsed_time(time / 60).to_s << "m "
+      end
+
+      def self.format_elapsed_time_in_seconds(time)
+        round_elapsed_time(time).to_s << "s "
+      end
+
+      def self.format_elapsed_time_in_milliseconds(time)
+        round_elapsed_time(time * 1_000).to_s << "ms"
+      end
+
+      def self.format_elapsed_time_in_microseconds(time)
+        round_elapsed_time(time * 1_000_000).to_s << "μs"
+      end
+
+      def self.round_elapsed_time(time)
+        "%.2f" % time
+      end
+    end
+  end
+end

data/lib/pakyow/logger.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require "console/filter"
+
+module Pakyow
+  # Logs messages throughout the lifetime of an environment, connection, etc.
+  #
+  # In addition to logging standard messages, this class provides a way to log a `prologue` and
+  # `epilogue` for a connection, as well as a `houston` method for logging errors.
+  #
+  class Logger < Console::Filter[internal: 0, debug: 1, info: 2, warn: 3, error: 4, fatal: 5, unknown: 6]
+    require "pakyow/logger/colorizer"
+    require "pakyow/logger/timekeeper"
+
+    # @!attribute [r] id
+    #   @return [String] the unique id of the logger instance
+    attr_reader :id
+
+    # @!attribute [r] started_at
+    #   @return [Time] the time when logging started
+    attr_reader :started_at
+
+    # @!attribute [r] type
+    #   @return [Symbol] the type of logger
+    attr_reader :type
+
+    # @param type [Symbol] the type of logging being done (e.g. :http, :sock)
+    # @param started_at [Time] when the logging began
+    # @param output [Object] the object that will perform the logging
+    # @param id [String] a unique id used to identify the request
+    def initialize(type, started_at: Time.now, id: SecureRandom.hex(4), output:, level:)
+      @type, @started_at, @id = type, started_at, id
+
+      level = case level
+      when :all
+        0
+      when :off
+        7
+      when Symbol
+        self.class.const_get(:LEVELS)[level]
+      else
+        level
+      end
+
+      super(output, level: level)
+    end
+
+    # Temporarily silences logs, up to +temporary_level+.
+    #
+    def silence(temporary_level = :error)
+      original_level = @level
+      self.level = self.class.const_get(:LEVELS)[temporary_level]
+      yield
+    ensure
+      self.level = original_level
+    end
+
+    LEVELS.keys.each do |method|
+      class_eval <<~CODE, __FILE__, __LINE__ + 1
+        def #{method}(message = nil, &block)
+          super(message) { decorate(message, &block) }
+        end
+      CODE
+    end
+
+    def <<(message)
+      add(:unknown, message)
+    end
+
+    def add(level, message = nil, &block)
+      public_send(level, message, &block)
+    end
+    alias log add
+
+    # Logs the beginning of a request, including the time, request method,
+    # request uri, and originating ip address.
+    #
+    # @param env [Hash] the rack env for the request
+    #
+    def prologue(connection)
+      info { formatted_prologue(connection) }
+    end
+
+    # Logs the conclusion of a request, including the response status.
+    #
+    # @param res [Array] the rack response array
+    #
+    def epilogue(connection)
+      info { formatted_epilogue(connection) }
+    end
+
+    # Logs an error raised when processing the request.
+    #
+    # @param error [Object] the error object
+    #
+    def houston(error)
+      error { formatted_error(error) }
+    end
+
+    def elapsed
+      (Time.now - @started_at)
+    end
+
+    private
+
+    def decorate(message = nil)
+      message = yield if block_given?
+      { "logger" => self, "message" => message }
+    end
+
+    def formatted_prologue(connection)
+      { "prologue" => connection }
+    end
+
+    def formatted_epilogue(connection)
+      { "epilogue" => connection }
+    end
+
+    def formatted_error(error)
+      { "error" => error }
+    end
+  end
+end

data/lib/pakyow/operation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+require "pakyow/support/makeable"
+require "pakyow/support/pipeline"
+require "pakyow/support/pipeline/object"
+
+require "pakyow/behavior/verification"
+
+module Pakyow
+  class Operation
+    extend Support::ClassState
+    class_state :__handlers, default: {}, inheritable: true
+
+    extend Support::Makeable
+
+    include Support::Pipeline
+    include Support::Pipeline::Object
+
+    attr_reader :app, :values
+
+    include Behavior::Verification
+    verifies :values
+
+    def initialize(app:, **values)
+      @app, @values = app, values
+    end
+
+    def perform
+      call(self)
+    rescue => error
+      if handler = self.class.__handlers[error.class] || self.class.__handlers[:global]
+        instance_exec(&handler); self
+      else
+        raise error
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      name = name.to_sym
+      if @values.key?(name)
+        @values[name.to_sym]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @values.key?(name.to_sym) || super
+    end
+
+    class << self
+      # Perform input verification before performing the operation
+      #
+      # @see Pakyow::Verifier
+      #
+      # @api public
+      def verify(&block)
+        define_method :__verify do
+          verify(&block)
+        end
+
+        action :__verify
+      end
+
+      def handle(error = nil, &block)
+        @__handlers[error || :global] = block
+      end
+    end
+  end
+end

data/lib/pakyow/plugin/helper_caller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Plugin
+    # @api private
+    class HelperCaller
+      def initialize(connection:, helpers:, plugin:)
+        @connection, @helpers, @plugin = connection, helpers, plugin
+      end
+
+      def method_missing(method_name, *args, &block)
+        @helpers.public_send(method_name, *args, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @helpers.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/pakyow/plugin/lookup.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Pakyow
+  class Plugin
+    # @api private
+    class Lookup
+      include Enumerable
+
+      extend Forwardable
+      def_delegators :@plugs, :each, :<<
+
+      def initialize(plugs)
+        @plugs = plugs
+      end
+
+      def finalize
+        @plugs.map { |plug|
+          plug.class.plugin_name
+        }.uniq.each do |plugin_name|
+          define_singleton_method plugin_name do |plugin_instance_name = :default|
+            plugin_instance_name = plugin_instance_name.to_sym
+
+            @plugs.find { |plug|
+              plug.class.plugin_name == plugin_name && plug.__object_name.namespace.parts.last == plugin_instance_name
+            }
+          end
+        end
+      end
+    end
+  end
+end