ree_lib 1.0.0

data/lib/ree_lib/packages/ree_logger/Package.schema.json

@@ -0,0 +1,67 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_logger",
+  "entry_path": "packages/ree_logger/package/ree_logger.rb",
+  "tags": [
+    "ree_logger"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_datetime"
+    },
+    {
+      "name": "ree_hash"
+    },
+    {
+      "name": "ree_object"
+    },
+    {
+      "name": "ree_validator"
+    }
+  ],
+  "env_vars": [
+    {
+      "name": "LOG_FILE_PATH",
+      "doc": null
+    },
+    {
+      "name": "LOG_LEVEL_FILE",
+      "doc": null
+    },
+    {
+      "name": "LOG_LEVEL_STDOUT",
+      "doc": null
+    },
+    {
+      "name": "LOG_RATE_LIMIT_COUNT",
+      "doc": null
+    },
+    {
+      "name": "LOG_RATE_LIMIT_INTERVAL",
+      "doc": null
+    }
+  ],
+  "objects": [
+    {
+      "name": "build_logger",
+      "schema": "packages/ree_logger/schemas/ree_logger/functions/build_logger.schema.json"
+    },
+    {
+      "name": "colorized_formatter",
+      "schema": "packages/ree_logger/schemas/ree_logger/formatters/colorized_formatter.schema.json"
+    },
+    {
+      "name": "config",
+      "schema": "packages/ree_logger/schemas/ree_logger/config.schema.json"
+    },
+    {
+      "name": "default_formatter",
+      "schema": "packages/ree_logger/schemas/ree_logger/formatters/default_formatter.schema.json"
+    },
+    {
+      "name": "logger",
+      "schema": "packages/ree_logger/schemas/ree_logger/beans/logger.schema.json"
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_logger/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree_lib/packages/ree_logger/package/ree_logger/appenders/appender.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class ReeLogger::Appender
+  attr_reader :level, :formatter
+
+  def initialize(level, formatter)
+    @level = level
+    @formatter = formatter
+  end
+
+  def append(log_event, progname = nil)
+    raise NotImplementedError, "should be implemented in derived class"
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/appenders/file_appender.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'appender'
+
+class ReeLogger::FileAppender < ReeLogger::Appender
+  include Ree::LinkDSL
+
+  link 'ree_logger/formatters/default_formatter', -> { DefaultFormatter }
+  link 'ree_logger/formatters/formatter', -> { Formatter }
+
+  DEFAULTS = {
+    auto_flush: false,
+    log_file_count: 10,
+    log_file_size: 1048576 # 1.megabyte
+  }.freeze
+
+  attr_reader :file, :auto_flush, :logger
+
+  contract(
+    Symbol,
+    Nilor[Formatter],
+    String,
+    Ksplat[
+      auto_flush?: Bool,
+      log_file_count?: Integer,
+      log_file_size?: Integer
+    ] => Any
+  )
+  def initialize(level, formatter, file_path, **opts)
+    super(
+      level,
+      formatter || DefaultFormatter.new
+    )
+
+    opts = DEFAULTS.merge(opts)
+
+    unless File.exists?(file_path)
+      FileUtils.mkdir_p(Pathname.new(file_path).parent.to_s)
+      FileUtils.touch(file_path)
+    end
+
+    @auto_flush = opts[:auto_flush]
+    @file = File.open(file_path, File::WRONLY | File::APPEND)
+
+    @logger = Logger.new(
+      @file, opts[:log_file_count], opts[:log_file_size]
+    )
+  end
+
+  contract(ReeLogger::LogEvent, Nilor[String] => nil)
+  def append(event, progname = nil)
+    message = @formatter.format(event, progname)
+    logger << (message + "\n")
+    file.flush if auto_flush
+
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/appenders/stdout_appender.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'appender'
+
+class ReeLogger::StdoutAppender < ReeLogger::Appender
+  include Ree::LinkDSL
+
+  link 'ree_logger/formatters/colorized_formatter', -> { ColorizedFormatter }
+  link 'ree_logger/formatters/formatter', -> { Formatter }
+
+  contract(
+    Symbol,
+    Nilor[Formatter] =>  Any
+  )
+  def initialize(level, formatter = nil)
+    super(
+      level,
+      formatter || ColorizedFormatter.new
+    )
+  end
+
+
+  contract ReeLogger::LogEvent, Nilor[String] => nil
+  def append(event, progname = nil)
+    message = @formatter.format(event, progname)
+    print(message + "\n")
+    STDOUT.flush
+
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/beans/logger.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class ReeLogger::Logger
+  include Ree::BeanDSL
+
+  bean :logger do
+    singleton
+    factory :build
+
+    link :build_logger
+    link :config
+    link :not_blank, from: :ree_object
+    link :is_blank, from: :ree_object
+    link 'ree_logger/rate_limiter', -> { RateLimiter }
+    link 'ree_logger/appenders/file_appender', -> { FileAppender }
+    link 'ree_logger/appenders/stdout_appender', -> { StdoutAppender }
+  end
+
+  def build
+    appenders = []
+
+    if config.levels.file
+      if is_blank(config.file_path)
+        raise ArgumentError, "use ENV['LOG_FILE_PATH'] to specify path to log file"
+      end
+
+      appenders << FileAppender.new(
+        config.levels.file, nil, config.file_path, auto_flush: config.file_auto_flush
+      )
+    end
+
+    if config.levels.stdout
+      appenders << StdoutAppender.new(
+        config.levels.stdout, nil
+      )
+    end
+
+    build_logger(
+      appenders,
+      ENV['APP_NAME'],
+      RateLimiter.new(
+        config.rate_limit.interval,
+        config.rate_limit.max_count
+      ),
+      config.default_filter_words
+    )
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/config.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class ReeLogger::Config
+  include Ree::BeanDSL
+
+  bean :config do
+    singleton
+    factory :build
+
+    link :to_obj, from: :ree_object
+    link :is_blank, from: :ree_object
+    link :validate_inclusion, from: :ree_validator
+  end
+
+  LEVELS = %w[warn info debug error fatal unknown].freeze
+  RATE_LIMIT_INTERVAL = 60
+  RATE_LIMIT_MAX_COUNT = 600
+
+  def build
+    to_obj({
+      file_path: ENV['LOG_FILE_PATH'],
+      file_auto_flush: parse_bool_string(ENV['LOG_FILE_AUTO_FLUSH']),
+      levels: {
+        file: parse_level(ENV['LOG_LEVEL_FILE']),
+        stdout: parse_level(ENV['LOG_LEVEL_STDOUT']),
+      },
+      rate_limit: {
+        interval: get_int_value('LOG_RATE_LIMIT_INTERVAL', RATE_LIMIT_INTERVAL),
+        max_count: get_int_value('LOG_RATE_LIMIT_MAX_COUNT', RATE_LIMIT_MAX_COUNT),
+      },
+      default_filter_words: %w[
+        password token credential bearer authorization
+      ]
+    })
+  end
+
+  private
+
+  def get_int_value(name, default)
+    value = ENV[name]
+
+    v = if value.to_s.strip.empty?
+      default
+    else
+      Integer(value)
+    end
+
+    if v < 0
+      raise ArgumentError, "ENV['#{name}'] should be > 0"
+    end
+
+    v
+  end
+
+  def parse_bool_string(bool)
+    return false if is_blank(bool)
+    return bool.to_s.downcase == "true"
+  end
+
+  def parse_level(level)
+    return if is_blank(level)
+    validate_inclusion(level, LEVELS)
+    level.to_sym
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/formatters/colorized_formatter.rb

@@ -0,0 +1,82 @@
+require_relative 'formatter'
+
+class ReeLogger::ColorizedFormatter < ReeLogger::Formatter
+  include Ree::BeanDSL
+
+  bean :colorized_formatter do
+    link 'ree_logger/log_event', -> { LogEvent }
+    link :not_blank, from: :ree_object
+    link :now, from: :ree_datetime
+  end
+
+  contract LogEvent, Nilor[String] => String
+  def format(event, progname = nil)
+    prefix = if progname
+      "[#{progname}] "
+    else
+      ""
+    end
+
+    level = "%-5s" % "#{event.level.to_s}:"
+    level = colorize_by_level(level, event.level)
+    out = "#{prefix}%-6s %s" % ["[#{now.strftime("%d/%m/%y %H:%M:%S")}]", colorize_message(level, event.message)]
+
+    if not_blank(event.parameters)
+      out += "#{prefix}\n#{colorize_blue('PARAMETERS:')} #{event.parameters}"
+    end
+
+    if event.exception
+      backtrace = (event.exception.backtrace || []).join("\n")
+      out += "#{prefix}\n#{colorize_red('EXCEPTION:')} #{event.exception.class} (#{event.exception.message})\n#{backtrace}"
+    end
+
+    out
+  end
+
+  private
+
+  def colorize_message(level, message)
+    if message =~ /(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)/
+      level = "\n\n#{level}"
+      message = colorize_blue(message)
+    elsif message =~ /Parameters: /
+      message = message.gsub("Parameters:", colorize_blue("Parameters:"))
+    elsif message =~ /SELECT/
+      message = message.gsub("SELECT", colorize_green("SELECT"))
+    elsif message =~ /(INSERT|UPDATE|DELETE)/
+      message = message.gsub($1, colorize_red($1))
+    end
+
+    "#{level} #{message}"
+  end
+
+  def colorize_by_level(string, level)
+    out = Rainbow(string)
+    case level
+    when :info
+      out.cyan
+    when :debug
+      out.yellow
+    when :warn
+      out.yellow
+    when :error
+      out.red
+    when :fatal
+      out.red
+    else
+      out.red
+    end
+  end
+
+  def colorize_green(string)
+    Rainbow(string).green
+  end
+
+  def colorize_blue(string)
+    Rainbow(string).blue
+  end
+
+  def colorize_red(string)
+    Rainbow(string).red
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/formatters/default_formatter.rb

@@ -0,0 +1,33 @@
+require_relative 'formatter'
+
+class ReeLogger::DefaultFormatter < ReeLogger::Formatter
+  include Ree::BeanDSL
+
+  bean :default_formatter do
+    link 'ree_logger/log_event', -> { LogEvent }
+    link :not_blank, from: :ree_object
+    link :now, from: :ree_datetime
+  end
+
+  contract LogEvent, Nilor[String] => String
+  def format(event, progname = nil)
+    prefix = if progname
+      "[#{progname}] "
+    else
+      ""
+    end
+
+    out = "#{prefix}%-6s %s %s" % ["[#{now.strftime("%d/%m/%y %H:%M:%S")}]", "#{event.level.to_s.upcase}:", event.message]
+
+    if not_blank(event.parameters)
+      out += "#{prefix}\nPARAMETERS: #{event.parameters}"
+    end
+
+    if event.exception
+      backtrace = (event.exception.backtrace || []).join("\n")
+      out += "#{prefix}\nEXCEPTION: #{event.exception.class} (#{event.exception.message})\n#{backtrace}"
+    end
+
+    out
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/formatters/formatter.rb

@@ -0,0 +1,5 @@
+class ReeLogger::Formatter
+  def format(event, progname = nil)
+    raise NotImplementedError, "should be implemented in derived class"
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/functions/build_logger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ReeLogger::BuildLogger
+  include Ree::FnDSL
+
+  fn :build_logger do
+    link 'ree_logger/appenders/appender', -> { Appender }
+    link 'ree_logger/multi_logger', -> { MultiLogger }
+    link 'ree_logger/rate_limiter', -> { RateLimiter }
+  end
+
+  contract(
+    ArrayOf[Appender],
+    Nilor[String],
+    Nilor[RateLimiter],
+    ArrayOf[String] => MultiLogger
+  )
+  def call(appenders, progname, rate_limiter, filter_words)
+    logger = MultiLogger.new(progname, rate_limiter, filter_words)
+
+    appenders.each do |appender|
+      logger.add_appender(appender)
+    end
+
+    logger
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/log_event.rb

@@ -0,0 +1,2 @@
+class ReeLogger::LogEvent < Struct.new(:level, :message, :exception, :parameters)
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/multi_logger.rb

@@ -0,0 +1,153 @@
+class ReeLogger::MultiLogger < Logger
+  include Ree::LinkDSL
+
+  link 'ree_logger/rate_limiter', -> { RateLimiter }
+  link 'ree_logger/log_event', -> { LogEvent }
+  link :transform_values, from: :ree_hash
+  link :as_json, from: :ree_object
+
+  undef level=
+  undef datetime_format
+  undef datetime_format=
+  undef sev_threshold=
+
+  LEVEL_MAPPING = {
+    debug: Logger::DEBUG,
+    info: Logger::INFO,
+    warn: Logger::WARN,
+    error: Logger::ERROR,
+    fatal: Logger::FATAL,
+    unknown: Logger::UNKNOWN
+  }
+
+  attr_reader :appenders, :silenced, :progname
+
+  contract(
+    Nilor[String],
+    Nilor[RateLimiter],
+    Nilor[ArrayOf[String]] => Any
+  )
+  def initialize(progname, rate_limiter, filter_words)
+    @progname = progname
+    @rate_limiter = rate_limiter
+    @filter_words = filter_words || []
+    @appenders = []
+    @silenced  = false
+  end
+
+  def add_appender(appender)
+    @appenders.push(appender)
+  end
+
+  contract Optblock => Bool
+  def silence(&block)
+    if block_given?
+      @silenced = true
+      block.call
+      unsilence
+    else
+      @silenced = true
+    end
+
+    @silenced
+  end
+
+  contract None => Bool
+  def unsilence
+    @silenced = false
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def debug(message, parameters = {}, exception = nil, log_args = false)
+    log(:debug, message, parameters, nil, false)
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def info(message, parameters = {}, exception = nil, log_args = false)
+    log(:info, message, parameters, nil)
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def warn(message, parameters = {}, exception = nil, log_args = false)
+    log(:warn, message, parameters, nil)
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def error(message, parameters = {}, exception = nil, log_args = true)
+    log(:error, message, parameters, exception, log_args)
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def fatal(message, parameters = {}, exception = nil, log_args = true)
+    log(:error, message, parameters, exception, true)
+  end
+
+  contract(String, Hash, Nilor[Exception], Bool => nil)
+  def unknown(message, parameters = {}, exception  =nil, log_args = true)
+    log(:unknown, message, parameters, exception, true)
+  end
+
+  contract(Symbol, String, Hash, Nilor[Exception], Bool => nil)
+  def log(level, message, parameters = {}, exception = nil, log_args = false)
+    if @rate_limiter
+      @rate_limiter.call do
+        log_event(level, message, parameters, exception, log_args)
+      end
+    else
+      log_event(level, message, parameters, exception, log_args)
+    end
+
+    nil
+  end
+
+  alias_method :add, :log
+
+  private
+
+  def log_event(level, message, parameters, exception, log_args)
+    return if @silenced if ![:error, :fatal].include?(level)
+
+    if log_args
+      begin
+        method_binding = binding.of_caller(2)
+        method_name = method_binding.eval('__method__')
+        obj = method_binding.eval('self')
+
+        args = {}
+
+        obj.method(method_name).parameters.each do |_, name|
+          args[name] = method_binding.local_variable_get(name)
+        end
+
+        args = transform_values(as_json(args)) do |k, v|
+          if @filter_words.any? { k.to_s.include?(_1) }
+            'FILTERED'
+          else
+            v
+          end
+        end
+
+        parameters[:method] = {}
+        parameters[:method][:name] = method_name
+        parameters[:method][:args] = args
+      rescue
+      end
+    end
+
+    event = LogEvent.new(level, message, exception, parameters)
+
+    appenders.each do |appender|
+      if higher_or_equal_level?(event.level, appender.level)
+        begin
+          appender.append(event, @progname)
+        rescue
+          # fail silently if logger is not working by some reason
+        end
+      end
+    end
+  end
+
+  def higher_or_equal_level?(message_level, appender_level)
+    LEVEL_MAPPING[message_level] >= LEVEL_MAPPING[appender_level]
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger/rate_limiter.rb

@@ -0,0 +1,26 @@
+class ReeLogger::RateLimiter
+  contract Integer, Integer => Any
+  def initialize(interval, max_rate)
+    @max_rate = max_rate
+    @interval = interval
+    @appends = []
+  end
+
+  def call(&block)
+    tick = Time.now.to_i
+    @appends.push(tick)
+    min = tick - @interval
+
+    loop do
+      if @appends.first < min
+        @appends.shift
+      else
+        break
+      end
+    end
+
+    if @appends.size < @max_rate
+      block.call
+    end
+  end
+end

data/lib/ree_lib/packages/ree_logger/package/ree_logger.rb

@@ -0,0 +1,21 @@
+require 'fileutils'
+require 'logger'
+require 'rainbow'
+require 'binding_of_caller'
+
+module ReeLogger
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_object
+    depends_on :ree_datetime
+    depends_on :ree_validator
+    depends_on :ree_hash
+
+    env_var 'LOG_FILE_PATH'
+    env_var 'LOG_LEVEL_FILE'
+    env_var 'LOG_LEVEL_STDOUT'
+    env_var 'LOG_RATE_LIMIT_INTERVAL'
+    env_var 'LOG_RATE_LIMIT_COUNT'
+  end
+end

data/lib/ree_lib/packages/ree_logger/schemas/ree_logger/beans/logger.schema.json

@@ -0,0 +1,46 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "logger",
+  "path": "packages/ree_logger/package/ree_logger/beans/logger.rb",
+  "mount_as": "object",
+  "class": "ReeLogger::Logger",
+  "factory": "build",
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_logger",
+      "package_name": "ree_logger",
+      "as": "build_logger",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "config",
+      "package_name": "ree_logger",
+      "as": "config",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "is_blank",
+      "package_name": "ree_object",
+      "as": "is_blank",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "not_blank",
+      "package_name": "ree_object",
+      "as": "not_blank",
+      "imports": [
+
+      ]
+    }
+  ]
+}