loggun 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8815d61a25fc71e36d6648e2e65fd7d6d73ebffd56e0b4631c95e589a5b9ced4
+  data.tar.gz: a6d4aea0a8971708fc3eb78eb42c50d99afb6fcbfec1e4dad5753c6552865566
+SHA512:
+  metadata.gz: aa4ee9f1f9d4a2fe3dae09083a9554c30d28d3821a5de8230db81efeef204e36e075c79335d4e7b587ead7a20da17cdf81b695acd6f00d27c751109ea2753902
+  data.tar.gz: 52768e02e7021307b455d5c5b7e2a55cda78152e61d387a2eff6cb1878060ea9b885d09b09c6b5f3c586eb9d33a0e8b6724e2827769f98d8c241f69920d16034

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*.gem
+/Gemfile.lock
+*.log

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,10 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.8
+  - 2.4.6
+  - 2.5.5
+  - 2.6.5
+before_install: gem install bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in loggun.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Aleksandr Noskov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# Loggun
+
+[![Sponsored by FunBox](https://funbox.ru/badges/sponsored_by_funbox_compact.svg)](https://funbox.ru)
+
+[![Gem Version](https://badge.fury.io/rb/loggun.svg)](https://badge.fury.io/rb/loggun)
+[![Build Status](https://travis-ci.org/funbox/loggun.svg?branch=master)](https://travis-ci.org/funbox/loggun)
+
+## Описание
+Loggun - это гем, позволяющий привести все логи приложения к единому формату
+
+## Установка
+
+Чтобы установить гем, добавьте в ваш Gemfile:
+
+```ruby
+gem 'loggun'
+```
+
+И выполните команду :
+
+    $ bundle
+
+## Использование
+
+### Конфигурация
+Для успешной конфигурации гема необходимо подгружать файл при инициализации вашего приложения.
+
+`config/initializers/loggun.rb`
+
+```ruby
+Loggun::Config.configure do |config|
+  config.precision = :milliseconds
+  config.pattern = '%{time} - %{pid} %{severity} %{type} %{tags_text} %{message}'
+  config.parent_transaction_to_message = false
+
+  config.modifiers.rails = true
+  config.modifiers.sidekiq = false
+  config.modifiers.clockwork = false
+  config.modifiers.incoming_http = false
+  config.modifiers.outgoing_http = false
+end
+```
+Все настройки являются опциональными.
+#### Настройки
+`precision` - точность отметок времени. По умолчанию - `milliseconds`. Может принимать одно из следующих значений: `sec`, `seconds`, `ms`, `millis`, `milliseconds`, `us`, `micros`, `microseconds`, `ns`, `nanos`, `nanoseconds`
+
+`pattern` - шаблон для формата вывода данных в лог. Доступные ключи: `time`, `pid`, `severity`, `type`, `tags_text`, `message`, `parent_transaction`
+
+`parent_transaction_to_message` - признак необходимости добавлять значение `parent_transaction` в тело логируемого сообщения. 
+Вне зависимости от данной настройки можно использовать ключ `parent_transaction` в шаблоне `pattern`.
+
+`modifiers` - модификаторы для переопределения формата логирования указанного компонента. См. далее.
+
+#### Модификаторы
+Каждый модифкатор может быть активирован двумя равнозначными способами:
+```ruby
+config.modifiers.rails = true
+```
+или
+```ruby
+config.modifiers.rails.enable = true
+```
+
+`rails` - модифицирует форматирование логгера Rails.
+
+`sidekiq` - модифицирует форматирование логгера Sidekiq.
+
+`clockwork` - модифицирует форматирование логгера Clockwork.
+
+`outgoing_http` - добавляет логирование исходящих http запросов. 
+На данный момент поддерживаются только запросы посредством гема `HTTP`.
+
+`incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
+Данный модификатор может иметь дополнительные настройки, которые устанавливаются следующим образом 
+(приведены значения по умолчанию):
+
+```ruby
+Loggun::Config.configure do |config|
+  #...
+  config.modifiers.incoming_http.enable = true
+  config.modifiers.incoming_http.controllers = ['ApplicationController']
+  config.modifiers.incoming_http.success_condition = -> { response.code == '200' }
+  config.modifiers.incoming_http.error_info = -> { nil }
+  #...
+end
+```
+
+`controllers` - массив имён базовых контроллеров, для которых необходимо добавить указанное логирование.
+
+`success_condition` - лямбда, определяющая, содержит ли успех ответ экшена. Например `-> { JSON.parse(response.body)['result'] == 'ok' }`
+
+`error_info` - лямбда, позволяющая добавить в лог информацию об ошибке, содержащейся в неуспешном ответе экшена. 
+Например `-> { JSON.parse(response.body)['error_code'] }`
+
+Помимо указанных модификаторов существует возможность добавить собственный. 
+Необходимо уснаследовать его от `Loggun::Modifiers::Base` и указать в методе `apply` все необходимые действия.
+```ruby
+require 'sinatra/custom_logger'
+
+class NewModifier < Loggun::Modifiers::Base
+  def apply
+    Loggun::Config.setup_formatter(Sinatra::CustomLogger)
+  end
+end
+```
+Затем необходимо добавить его при конфигурации гема.
+
+```ruby
+Loggun::Config.configure do |config|
+  #...
+  config.add_mofifier NewModifier
+  #...
+end
+```
+
+### Хелперы
+Подключение хелперов в класс позволяет использовать методы логирования `log_info` и `log_error`, 
+а также генерировать идентификатор транзации для каждого метода класса.
+
+Например:
+```ruby
+class SomeClass
+  include Loggun::Helpers
+
+  log_options entity_action: :method_name, as_transaction: true
+
+  def some_action
+    log_info 'type_for_action', 'Information'
+    bar
+  end
+
+  def bar
+    log_info 'type_for_bar', 'Bar information'
+  end
+end
+```
+Даёт подобный вывод в лог:
+```
+2020-03-04T16:58:38.207+05:00 - 28476 INFO type_for_action.some_class.some_action#msg_id_1583323118203 - {"value":["Information"]}
+2020-03-04T16:58:38.208+05:00 - 28476 INFO type_for_bar.some_class.bar#msg_id_1583323118207 - {"value":["Bar information"],"parent_transaction":"class.geo_location__actual_location.fetch_input#msg_id_1583323118203"}
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'loggun'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/loggun/config.rb

@@ -0,0 +1,91 @@
+require 'singleton'
+
+module Loggun
+  ## Class for configurations
+  class Config
+    include Singleton
+
+    DEFAULTS = {
+      pattern: '%{time} - %{pid} %{severity} %{type} %{tags_text}%{agent} %{message}',
+      parent_transaction_to_message: true,
+      precision: :milliseconds,
+      incoming_http: {
+        controllers: %w[ApplicationController],
+        success_condition: -> { response.code == '200' },
+        error_info: -> { nil }
+      }
+    }.freeze
+    DEFAULT_MODIFIERS = %i[rails sidekiq clockwork incoming_http outgoing_http].freeze
+
+    attr_accessor(
+      :formatter,
+      :pattern,
+      :parent_transaction_to_message,
+      :precision,
+      :modifiers,
+      :custom_modifiers
+    )
+
+    def initialize
+      @formatter = Loggun::Formatter.new
+      @precision = DEFAULTS[:precision]
+      @pattern = DEFAULTS[:pattern]
+      @parent_transaction_to_message = DEFAULTS[:parent_transaction_to_message]
+      @modifiers = Loggun::OrderedOptions.new
+      @custom_modifiers = []
+      set_default_modifiers
+    end
+
+    class << self
+      def configure(&block)
+        block.call(instance)
+        use_modifiers
+        instance
+      end
+
+      def use_modifiers
+        DEFAULT_MODIFIERS.each do |modifier|
+          next unless instance.modifiers.public_send(modifier)&.enable
+
+          require_relative "modifiers/#{modifier}"
+          klass = Loggun::Modifiers.const_get(modifier.to_s.camelize)
+          klass.use
+        end
+
+        instance.custom_modifiers.each(&:use)
+      end
+
+      def setup_formatter(app)
+        Loggun.application = app
+        Loggun.application.logger.formatter = instance.formatter
+      end
+    end
+
+    def set_default_modifiers
+      DEFAULT_MODIFIERS.each do |modifier|
+        modifiers[modifier] = Loggun::OrderedOptions.new
+        modifiers[modifier].enable = false
+        next unless DEFAULTS[modifier].is_a?(Hash)
+
+        modifiers[modifier].merge!(DEFAULTS[modifier])
+      end
+    end
+
+    def add_modifier(modifier)
+      return unless modifier.respond_to? :use
+
+      custom_modifiers << modifier
+    end
+
+    def timestamp_precision
+      case precision
+      when :sec, :seconds then 0
+      when :millis, :milliseconds, :ms then 3
+      when :micros, :microseconds, :us then 6
+      when :nanos, :nanoseconds, :ns then 9
+      else
+        3 # milliseconds
+      end
+    end
+  end
+end

data/lib/loggun/formatter.rb

@@ -0,0 +1,80 @@
+require 'date'
+
+module Loggun
+  class Formatter
+    DEFAULT_VALUE = '-'.freeze
+
+    def call(severity, time, _program_name, message)
+      data = Hash.new(DEFAULT_VALUE)
+      data[:time] = time.iso8601(config.timestamp_precision)
+      data[:pid] = Process.pid
+
+      if message.is_a?(Hash)
+        if config.parent_transaction_to_message && parent_transaction
+          message[:parent_transaction] = parent_transaction
+        end
+        message = JSON.generate(message)
+      end
+
+      data[:message] = message.to_s.tr("\r\n", ' ').strip
+      data[:severity] = severity&.present? ? severity.to_s : 'INFO'
+      data[:tags_text] = tags_text
+      data[:type] = Loggun.type || DEFAULT_VALUE.dup
+      data[:transaction_id] = Loggun.transaction_id
+      data[:parent_transaction] = parent_transaction if parent_transaction
+
+      if data[:transaction_id]&.to_i != Process.pid && data[:type] != DEFAULT_VALUE
+        data[:type] = "#{data[:type]}##{data[:transaction_id]}"
+      end
+
+      format(config.pattern + "\n", data)
+    end
+
+    def tagged(*tags)
+      new_tags = push_tags(*tags)
+      yield self
+    ensure
+      pop_tags(new_tags.size)
+    end
+
+    def push_tags(*tags)
+      tags.flatten.reject(&:blank?).tap do |new_tags|
+        current_tags.concat new_tags
+      end
+    end
+
+    def pop_tags(size = 1)
+      current_tags.pop size
+    end
+
+    def clear_tags!
+      current_tags.clear
+    end
+
+    def current_tags
+      thread_key = @thread_key ||= "loggun_tagged_logging_tags:#{object_id}"
+      Thread.current[thread_key] ||= []
+    end
+
+    def tags_text
+      tags = current_tags
+      if tags.one?
+        "[#{tags[0]}] "
+      elsif tags.any?
+        tags.collect { |tag| "[#{tag}] " }.join
+      end
+    end
+
+    private
+
+    def parent_transaction
+      return unless Loggun.parent_type && Loggun.parent_transaction_id
+
+      "#{Loggun.parent_type}##{Loggun.parent_transaction_id}"
+    end
+
+    def config
+      Loggun::Config.instance
+    end
+  end
+end

data/lib/loggun/helpers.rb

@@ -0,0 +1,178 @@
+require 'securerandom'
+
+module Loggun
+  module Helpers
+    SKIPPED_METHODS = %i[
+      initialize loggun logger modified_methods
+    ].freeze
+    DEFAULT_TYPE = 'class'.freeze
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.init
+    end
+
+    module ClassMethods
+      attr_accessor(
+        :with_log_transaction_id,
+        :log_transaction_generator,
+        :log_entity_name,
+        :log_entity_action,
+        :modified_methods,
+        :generate_transaction_except
+      )
+
+      def log_options(**options)
+        @log_entity_name = options[:entity_name]
+        @log_entity_action = options[:entity_action]
+        @with_log_transaction_id = options[:as_transaction]
+        @log_transaction_generator = options[:transaction_generator]
+        @generate_transaction_except = options[:generate_transaction_except]&.map(&:to_sym)
+      end
+
+      def init
+        @modified_methods = []
+      end
+
+      def method_added(method_name)
+        super
+        @modified_methods ||= []
+        return if SKIPPED_METHODS.include?(method_name) ||
+                  modified_methods.include?(method_name)
+
+        modified_methods << method_name
+        method = instance_method(method_name)
+        undef_method(method_name)
+
+        define_method(method_name) do |*args, &block|
+          if self.class.generate_transaction_except&.include?(method_name.to_sym)
+            method.bind(self).call(*args, &block)
+          else
+            type = log_type(nil, method_name)
+            in_transaction(type) do
+              method.bind(self).call(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    %i[unknown fatal error warn info debug].each do |method|
+      define_method("log_#{method}") do |*args, **attrs, &block|
+        type = args.shift
+        next application.logger.send(method, type, &block) if args.empty? &&
+                                                              attrs.empty?
+
+        method_name = caller_locations.first.label.split(' ').last
+        type = log_type(type, method_name)
+
+        if %i[fatal error].include?(method)
+          methods = args.first.methods
+          next unless methods.include?(:message) && methods.include?(:backtrace)
+
+          error = args.shift
+          attrs[:error] = { class: error.class, msg: error.message }
+          if attrs[:hidden]
+            attrs[:hidden][:error] = { backtrace: error.backtrace }
+          else
+            attrs[:hidden] = { error: { backtrace: error.backtrace } }
+          end
+        end
+        attrs[:value] = args if args.present?
+
+        with_type(type) do
+          application.logger.send(method, **attrs, &block)
+        end
+      end
+    end
+
+    %w[type transaction_id].each do |method_name|
+      %I[#{method_name} parent_#{method_name}].each do |method|
+        define_method(method) { Thread.current["loggun_#{method}".to_sym] }
+
+        define_method("#{method}=") do |value|
+          value = normalize(value) if method == :type
+
+          Thread.current["loggun_#{method}".to_sym] = value
+        end
+      end
+    end
+
+    def in_transaction(current_type = nil, current_transaction_id = nil)
+      current_transaction_id ||= generate_log_transaction_id
+      previous_transaction_id = self.parent_transaction_id
+      previous_type = self.parent_type
+
+      self.parent_transaction_id = self.transaction_id
+      self.parent_type = self.type
+
+      self.transaction_id = current_transaction_id
+      self.type = current_type if current_type
+      yield
+    ensure
+      self.transaction_id = self.parent_transaction_id
+      self.type = self.parent_type
+
+      self.parent_transaction_id = previous_transaction_id
+      self.parent_type = previous_type
+    end
+
+    def with_type(current_type)
+      previous_type = self.type
+      self.type = current_type
+      yield
+    ensure
+      self.type = previous_type
+    end
+
+    def log_type(type, method_name)
+      type ||= DEFAULT_TYPE.dup
+      type_as_arr = type.split('.')
+      klass = self.class
+      log_entity_name = klass.log_entity_name if klass.respond_to?(:log_entity_name)
+      log_entity_name ||= underscore(klass.name)
+      type << ".#{log_entity_name}" if type_as_arr.size == 1
+
+      return type unless klass.respond_to?(:log_entity_action)
+
+      if klass.log_entity_action && type_as_arr.size < 3
+        if klass.log_entity_action == :method_name && method_name
+          type << ".#{method_name}"
+        end
+      end
+
+      type
+    end
+
+    private
+
+    def normalize(type)
+      return unless type
+
+      type = type.to_s.strip.tr(" \t\r\n", ' ').squeeze(' ')
+      type.empty? ? nil : type
+    end
+
+    def underscore(word)
+      word.gsub!(/::/, '__')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+
+    def generate_log_transaction_id
+      return unless self.class.with_log_transaction_id
+      if self.class.log_transaction_generator
+        return self.class.log_transaction_generator.call
+      end
+
+      "#{SecureRandom.uuid[0..7]}_#{DateTime.now.strftime('%Q')}"
+    end
+
+    def application
+      Loggun.application
+    end
+  end
+end

data/lib/loggun/modifiers/base.rb

@@ -0,0 +1,19 @@
+require 'singleton'
+
+module Loggun
+  module Modifiers
+    class Base
+      include Singleton
+
+      class << self
+        def use
+          instance.apply
+        end
+      end
+
+      def apply
+        raise NotImplementedError, 'You must implement #apply in your modifier.'
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/clockwork/manager.rb

@@ -0,0 +1,20 @@
+require 'clockwork/manager'
+
+Clockwork::Manager.class_eval do
+  def configure_loggun
+    yield(config)
+    setup_formatter
+    if config[:sleep_timeout] < 1
+      config[:logger].warn 'sleep_timeout must be >= 1 second'
+    end
+  end
+
+  private
+
+  def setup_formatter
+    return unless Loggun::Config.instance.modifiers.clockwork
+
+    Loggun::Config.setup_formatter(self)
+  end
+end
+

data/lib/loggun/modifiers/clockwork/methods.rb

@@ -0,0 +1,9 @@
+require 'clockwork'
+
+module Clockwork
+  module Methods
+    def configure(&block)
+      Clockwork.manager.configure_loggun(&block)
+    end
+  end
+end

data/lib/loggun/modifiers/clockwork.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+if defined?(::Clockwork)
+  require_relative 'clockwork/manager'
+  require_relative 'clockwork/methods'
+end
+
+module Loggun
+  module Modifiers
+    class Clockwork < Loggun::Modifiers::Base
+      def apply
+        return unless defined?(::Clockwork)
+
+        ::Clockwork.configure {}
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/incoming_http/log_http_actions.rb

@@ -0,0 +1,36 @@
+module LogHttpActions
+
+  private
+
+  def log_http_actions
+    log_action :start
+    yield
+    log_action :response
+  end
+
+  def log_action(action = :start)
+    api = request.path[/\w+/]
+    api_version = request.path[/v./]
+    type = "http_request.#{api}.#{action}"
+    data = { path: clean_pathname, api_version: api_version }
+    return Loggun.info type, data if action == :start
+
+    success = instance_exec(&modifier_config.success_condition)
+    data[:success] = success
+    unless success
+      error = instance_exec(&modifier_config.error_info)
+      data[:error] = error if error
+    end
+    Loggun.info type, data
+  end
+
+  def clean_pathname
+    filtered_params = params.to_unsafe_h
+    filtered_params.delete('action')
+    request.path.gsub(/(#{filtered_params.values.join('|')})/, '').gsub(/\/api\/v./, '')
+  end
+
+  def modifier_config
+    Loggun::Config.instance.modifiers.incoming_http
+  end
+end

data/lib/loggun/modifiers/incoming_http.rb

@@ -0,0 +1,19 @@
+require_relative 'incoming_http/log_http_actions'
+
+module Loggun
+  module Modifiers
+    class IncomingHttp < Loggun::Modifiers::Base
+      def apply
+        return unless defined?(ActionPack)
+
+        controllers = Loggun::Config.instance.modifiers.incoming_http.controllers
+        controllers.each do |controller|
+          controller.constantize.class_eval do
+            include LogHttpActions
+            around_action :log_http_actions
+          end
+        end
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/outgoing_http/block_logger.rb

@@ -0,0 +1,11 @@
+class BlockLogger
+  class << self
+    %i[unknown fatal error warn info debug].each do |method|
+      define_method(method) do |&block|
+        type = 'http_requests.outgoing.'
+        type += caller[0][/request/] ? 'start' : 'response'
+        Loggun.send("log_#{method}".to_sym, type, args, &block)
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/outgoing_http.rb

@@ -0,0 +1,18 @@
+require 'http' if defined?(HTTP)
+require_relative 'outgoing_http/block_logger'
+
+module Loggun
+  module Modifiers
+    class OutgoingHttp < Loggun::Modifiers::Base
+      def apply
+        return unless defined?(HTTP)
+
+        ::HTTP.default_options = {
+          features: {
+            logging: { logger: BlockLogger }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/rails/railtie.rb

@@ -0,0 +1,13 @@
+require 'rails/railtie'
+
+module Loggun
+  module Modifiers
+    class Rails
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do |_app|
+          Loggun::Config.setup_formatter(::Rails)
+        end
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/rails.rb

@@ -0,0 +1,9 @@
+module Loggun
+  module Modifiers
+    class Rails < Loggun::Modifiers::Base
+      def apply
+        require_relative 'rails/railtie' if defined?(::Rails)
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/sidekiq.rb

@@ -0,0 +1,15 @@
+require 'sidekiq' if defined?(::Sidekiq)
+
+module Loggun
+  module Modifiers
+    class Sidekiq < Loggun::Modifiers::Base
+      def apply
+        return unless defined?(::Sidekiq)
+
+        ::Sidekiq.configure_server do |config|
+          Loggun::Config.setup_formatter(config)
+        end
+      end
+    end
+  end
+end

data/lib/loggun/modifiers.rb

@@ -0,0 +1,4 @@
+module Loggun
+  module Modifiers
+  end
+end

data/lib/loggun/ordered_options.rb

@@ -0,0 +1,38 @@
+module Loggun
+  class OrderedOptions < Hash
+    alias _get [] # preserve the original #[] method
+    protected :_get # make it protected
+
+    def []=(key, value)
+      if self[key.to_sym].is_a?(Loggun::OrderedOptions) &&
+         [true, false].include?(value)
+        return self[key.to_sym][:enable] = value
+      end
+
+      super(key.to_sym, value)
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def method_missing(name, *args)
+      name_string = +name.to_s
+      if name_string.chomp!('=')
+        self[name_string] = args.first
+      else
+        bangs = name_string.chomp!('!')
+
+        if bangs
+          self[name_string].presence || raise(KeyError, ":#{name_string} is blank")
+        else
+          self[name_string]
+        end
+      end
+    end
+
+    def respond_to_missing?(_name, _include_private)
+      true
+    end
+  end
+end

data/lib/loggun/version.rb

@@ -0,0 +1,3 @@
+module Loggun
+  VERSION = '0.1.0'.freeze
+end

data/lib/loggun.rb

@@ -0,0 +1,21 @@
+require 'loggun/version'
+require 'loggun/ordered_options'
+require 'loggun/formatter'
+require 'loggun/config'
+require 'loggun/modifiers'
+require 'loggun/modifiers/base'
+require 'loggun/helpers'
+
+module Loggun
+  class Error < StandardError; end
+
+  class << self
+    include Loggun::Helpers
+
+    attr_accessor :application
+
+    %i[unknown fatal error warn info debug].each do |method|
+      alias_method method, "log_#{method}"
+    end
+  end
+end

data/loggun.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'loggun/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'loggun'
+  spec.version       = Loggun::VERSION
+  spec.authors       = ['Aleksandr Noskov', 'Sergey Nesterov']
+  spec.email         = ['nemestny@politeh.ru', 'qnesterr@gmail.com']
+
+  spec.summary       = 'Loggun'
+  spec.description   = 'Gem for formatting ruby application logs'
+  spec.homepage      = 'https://github.com/funbox/loggun'
+  spec.license       = 'MIT'
+
+  # spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  # spec.metadata['changelog_uri'] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'clockwork', '~> 2.0'
+  spec.add_development_dependency 'http', '~> 4.0'
+  spec.add_development_dependency 'rails', '~> 6.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-rails', '~> 3.0'
+  spec.add_development_dependency 'sidekiq', '~> 6.0'
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: loggun
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aleksandr Noskov
+- Sergey Nesterov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: clockwork
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Gem for formatting ruby application logs
+email:
+- nemestny@politeh.ru
+- qnesterr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/loggun.rb
+- lib/loggun/config.rb
+- lib/loggun/formatter.rb
+- lib/loggun/helpers.rb
+- lib/loggun/modifiers.rb
+- lib/loggun/modifiers/base.rb
+- lib/loggun/modifiers/clockwork.rb
+- lib/loggun/modifiers/clockwork/manager.rb
+- lib/loggun/modifiers/clockwork/methods.rb
+- lib/loggun/modifiers/incoming_http.rb
+- lib/loggun/modifiers/incoming_http/log_http_actions.rb
+- lib/loggun/modifiers/outgoing_http.rb
+- lib/loggun/modifiers/outgoing_http/block_logger.rb
+- lib/loggun/modifiers/rails.rb
+- lib/loggun/modifiers/rails/railtie.rb
+- lib/loggun/modifiers/sidekiq.rb
+- lib/loggun/ordered_options.rb
+- lib/loggun/version.rb
+- loggun.gemspec
+homepage: https://github.com/funbox/loggun
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/funbox/loggun
+  source_code_uri: https://github.com/funbox/loggun
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Loggun
+test_files: []