xyeger 0.3.4 → 1.0.0.rc

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c68d166158a0f8b44ff3478dc3d56b3bd2cc9fc
-  data.tar.gz: 66012ae7e1fb5de36f145a53f12985311a60f5ce
+  metadata.gz: e0455bfab0a7b4d2b8a48cdf8ddd6d0fd70a9102
+  data.tar.gz: e53aa11125c2073b0016e7bc91fa1d37f2105958
 SHA512:
-  metadata.gz: 5c638e78858363d24b1a6684fe4941c9ba52e85a2ec12adc23899c8cab86efc016995b6518a0437cfbf7ba1c58d565878f59ace87170806e3302a2c8158cad43
-  data.tar.gz: f818798916ace388014c23ee135e180193b8936cad86eee90dc99e5ccbcc061d310fc0281f79998de159ab61c174efed1cb9a39a0cb2daa20ef227205cb50d88
+  metadata.gz: b92dca5942df0257ac51ff47d031ec86ce757810c0ae1444350b9ace0551da175ca99c14de456d1cfe8301a33c2163c665b638cf46882c8dcac4603910ca2377
+  data.tar.gz: 0c6297439b58999e9c5a218ce773a30987394444282c8b9f6f5160e311318ae9938485db524d71a74586e0eccf2989ca2ac5a3f8a4a353ba7eee7314fdefc67c

data/.rubocop.yml

@@ -0,0 +1,65 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  DisplayCopNames: true
+  Exclude:
+    - bin/*
+    - vendor/**/*
+    - spec/spec_helper.rb
+    - spec/rails_helper.rb
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+    - xyeger.gemspec
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/BlockDelimiters:
+  EnforcedStyle: braces_for_chaining
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/FirstParameterIndentation:
+  EnforcedStyle: consistent
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/IndentArray:
+  EnforcedStyle: consistent
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/RescueModifier:
+  Exclude:
+    - spec/**/*
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false

data/Gemfile.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    xyeger (0.3.4)
+      actionpack (>= 4)
+      activesupport (>= 4)
+      railties (>= 4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (5.1.2)
+      actionview (= 5.1.2)
+      activesupport (= 5.1.2)
+      rack (~> 2.0)
+      rack-test (~> 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.1.2)
+      activesupport (= 5.1.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activesupport (5.1.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ast (2.3.0)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    erubi (1.6.1)
+    i18n (0.8.6)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    method_source (0.8.2)
+    mini_portile2 (2.2.0)
+    minitest (5.10.3)
+    nokogiri (1.8.0)
+      mini_portile2 (~> 2.2.0)
+    parallel (1.11.2)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rack (2.0.3)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.3)
+      loofah (~> 2.0)
+    railties (5.1.2)
+      actionpack (= 5.1.2)
+      activesupport (= 5.1.2)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rainbow (2.2.2)
+      rake
+    rake (10.5.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rubocop (0.49.1)
+      parallel (~> 1.10)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    thor (0.19.4)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.14)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rubocop
+  xyeger!
+
+BUNDLED WITH
+   1.15.1

data/README.md

@@ -1,6 +1,49 @@
 # Xyeger
 
-## Installation
+## Table of content
+
+- [Basic Usage](#basic-usage)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+  - [Context](#context)
+  - [Context Resolver](#context-resolver)
+  - [Message Resolver](#message-resolver) 
+- [Formatters](#formatters)
+  - [Base Formatter](#base-formatter)
+  - [JSON Formatter](#json-formatter)
+  - [Values Formatter](#values-formatter)
+  - [Text Formatter](#text-formatter)
+  - [Custom Formatter](#custom-formatter)
+- [Integrations](#integrations)
+  - [Rails](#rails)
+  - [Grape](#grape)
+  - [Sidekiq](#sidekiq)
+  - [Sentry](#sentry)
+  - [Plain ruby app](#plain-ruby-app)
+## Basic Usage
+Xyeger Logger was created to be suitable with ElasticSearch logs, so when you log anything you will get JSON representation of your message. 
+
+```ruby
+Xyeger.configure {}
+logger = Logger.new(STDOUT)
+logger.extend(Xyeger::Logger)
+logger.info('Some message')
+```
+
+```json
+{
+  "hostname": "",
+  "pid": 61915,
+  "app": "",
+  "env": "",
+  "level": "INFO",
+  "time": "2017-08-03 16:24:57 +0300",
+  "message": "Some message",
+  "context": {}
+}
+```
+
+### Installation
 
 Add this line to your application's Gemfile:
 
@@ -16,183 +59,227 @@ Or install it yourself as:
 
     $ gem install xyeger
 
-## Usage
-
 ### Configuration
 
 Add environments:
+
 ```bash
-XYEGER_HOSTNAME='LoggerApplication' #f.e.: rails, sidekiq, sneakers
+XYEGER_HOSTNAME='localhost' #f.e.: rails, sidekiq, sneakers
+XYEGER_APPNAME='some_service'
+XYEGER_ENV='staging'
 ```
 
 Add into initializer file:
-```ruby
-#config/initializers/xyeger.rb
-Xyeger.configure do |config|
-  config.filter_parameters = Rails.application.config.filter_parameters
-end
-```
-|          Formatter           |   Description    | Options |
-| ---------------------------- | ---------------- | ------- |
-| `Xyeger::Formatters::Base`   |                  | colored |
-| `Xyeger::Formatters::Json`   | default format   | colored |
-| `Xyeger::Formatters::Values` | show only values | colored |
 
-Default options:
 ```ruby
 #config/initializers/xyeger.rb
 Xyeger.configure do |config|
-  config.output = STDOUT
-  config.formatter = Xyeger::Formatters::Values.new
-  config.filter_parameters = Rails.application.config.filter_parameters
-  config.hostname = ENV['XYEGER_HOSTNAME']
-  config.app = Rails.application.class.parent_name
-  config.env = Rails.env
+  config.output = STDOUT                      # default to STDOUT
+  config.formatter = MyCustomFormatter        # default to Xyeger::Formatters::Json.new
+  config.app = ''                             # default to ENV['XYEGER_APPNAME'] or emtpy string
+  config.env = Rails.env                      # default to ENV['XYEGER_ENV'] or empty string
+  config.context_resolver = MyContextResolver # ContextResolver class
+  config.message_resolver = MyMessageResolver # MessageResolver class
 end
 ```
 
-For colored output use option `colored` (gem [Paint](https://github.com/janlelis/paint))
+### Context
+It was found out that just JSON-looking logs does not solve the problem of tracking request flow. So context was added. 
+
 ```ruby
-config.xyeger.formatter = Xyeger::Formatters::Values.new(colored: true)
+  Xyeger.add_context(flow_id: SecureRandom.uuid)
+  logger.debug('With Context')
 ```
 
-## Output results
-
-### Http request
-```bash
-curl localhost:3000 -G -d a=3
-```
 ```json
 {
- "logger": "puma: cluster worker 1: 29117 [cryptopay]",
- "pid": 29141,
- "app": "Cryptopay",
- "env": "development",
- "level": "INFO",
- "time": "2017-06-29T15:42:14.761+03:00",
- "caller": null,
- "msg": "Lograge message",
- "context":
-  {"method": "GET",
-   "path": "/",
-   "format": "*/*",
-   "controller": "PagesController",
-   "action": "index",
-   "status": 200,
-   "duration": 1852.79,
-   "view": 703.55,
-   "db": 29.07,
-   "params": {"a": "3"}}
+  "hostname": "",
+  "pid": 61915,
+  "app": "",
+  "env": "",
+  "level": "DEBUG",
+  "time": "2017-08-03 16:26:38 +0300",
+  "message": "With Context",
+  "context": {
+    "flow_id": "6821a053-ad20-4d58-905a-25a923f7a412"
+  }
 }
 ```
 
-### Raise an error
-```json
-{
-  "logger":"puma",
-  "pid":24886,
-  "app":"Cryptopay",
-  "env":"development",
-  "level":"ERROR",
-  "time":"2017-06-29T15:17:07.736+03:00",
-  "caller":"/home/vsevolod/work/cryptopay/cryptopay/app/services/ticker_service.rb:159",
-  "msg": "StandardError",
-  "context":
-   {
-        "class": "TickerService::TickerNotFound",
-        "error": "Active ticker not found EUR/USD"
-   }
-}
+### Context Resolver
+
+You are not wired to add only hash object to context, but in that keys you might want to create your own `ContextResolver`, which expect `self.call(object)` method and return hash-representation at the end.
+
+```ruby
+class MyContextResolver
+  def self.call(object)
+    case object
+    when User
+      { user_id: object.uuid }
+    end
+  end
+end  
+
+Xyeger.configure { config.context_resolver = MyContextResolver }
+
+user = User.first
+Xyeger.add_context(user)
+```
+
+### Message Resolver
+
+Same way as it is done in context resolver you might find useful to create your own `MessageResolver`, which expect `self.call(message, progname)` method to be implemented and return string at the end.
+
+```ruby
+class MessageResolver
+  def self.call(message, progname)
+    message =
+      case message
+      when ::StandardError
+        [message.class.name, message].compact.join(' ')
+      else
+        message.to_s
+      end
+    [progname, message].compact.join(' ')
+  end
+end
+
+Xyeger.configure { config.message_resolver = MyContextResolver }
+
+begin
+  raise
+rescue => error
+  Xyeger.add_context(error)
+  raise error
+end
 ```
 
-### Manual log usage
+
+## Formatters
+By default you have following formatters
+
+|          Formatter           |   Description    |
+| ---------------------------- | ---------------- |
+| `Xyeger::Formatters::Base`   |                  |
+| `Xyeger::Formatters::Json`   | default formater |
+| `Xyeger::Formatters::Values` | show only values |
+| `Xyeger::Formatters::Text`   | show text form   |
+
+### Base formatter
+All built-in formatters inherit from `Xyeger::Formatters::Base`, which prepare result hash with following keys: `hostname`, `pid`, `app`, `env`, `level`, `time`, `message`, `context`.
+
+### JSON Formatter
+Default representation of logs:
+
 ```ruby
-Rails.logger.info('Logger message', { content: '1', params: 'b' })
+logger.formatter = Xyeger::Formatters::Json.new # default formatter
 ```
 ```json
 {
-  "logger":"bin/rails",
-  "pid":22796,
-  "app":"Cryptopay",
-  "env":"development",
-  "level":"INFO",
-  "time":"2017-06-30T13:45:22.070+03:00",
-  "caller":null,
-  "message":"Logger message",
-  "context":
-  {
-    "content":"1",
-    "params":"b"
+  "hostname": "",
+  "pid": 61915,
+  "app": "",
+  "env": "",
+  "level": "DEBUG",
+  "time": "2017-08-03 16:26:38 +0300",
+  "message": "With Context ",
+  "context": {
+    "flow_id": "6821a053-ad20-4d58-905a-25a923f7a412"
   }
 }
+```
 
+### Values Formatter
+All the values of Base formatter hash concatenated with `space` delimiter.
+
+```ruby
+logger.formatter = Xyeger::Formatters::Values.new
+```
 ```
+ 61915   DEBUG 2017-08-03 17:00:07 +0300 With Context  {:flow_id=>"6821a053-ad20-4d58-905a-25a923f7a412"}
+```
+
+### Text Formatter
+Context represented via list of key-value. Message is just string at the end 
 
-## Grape usage
-WIth ```gem 'grape_logging'```
 ```ruby
-class Root < Grape::API
-  # Message: {
-  #  "status":200,
-  #  "time":
-  #  {
-  #    "total":86.84,
-  #    "db":15.27,
-  #    "view":71.57
-  #  },
-  #  "method":"GET",
-  #  "path":"/api/v2/tickers",
-  #  "params":{"password":"[FILTERED]","a":"b"},
-  #  "ip":"127.0.0.1",
-  #  "ua":"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:54.0) Gecko/20100101 Firefox/54.0"
-  #}
-  formatter = Xyeger::Formatters::Json.new(
-    message: ->(message, _context) { "#{message[:method]} #{message[:path]}" },
-    context: ->(message, _context) { message }
-  )
-
-  use GrapeLogging::Middleware::RequestLogger,
-    logger: logger,
-    formatter: formatter,
-    include: [
-      GrapeLogging::Loggers::Response.new,
-      GrapeLogging::Loggers::FilterParameters.new,
-      GrapeLogging::Loggers::ClientEnv.new
-    ]
-end
+logger.formatter = Xyeger::Formatters::Text.new
+```
 ```
+ [2017-08-03 16:59:51 +0300] [DEBUG] flow_id=6821a053-ad20-4d58-905a-25a923f7a412 With Context 
+```
+
+### Custom Formatter
+You are free to implement your own formatters, but things to be mentioned: if you need all default keys accessible inside your formatter, you have to inherit from `Xyeger::Formatters::Base` formatter. See `lib/xyeger/formatters` directory for more info.
 
-## Sidekiq usage
+## Integrations
+You can easily use `Xyeger` with different type of applications and here are some built in integrations
+
+### Rails
+Integration with `rails` add `Xyeger::Rails::FlowIdMiddlare` in application middlware stack so it will automatically add end-to-end identifier(`:fid`) inside context for each request and clear it out when request is ended.
+
+### Grape
+Grape has it's own logger inside. Most of the time you create extra module to specify logging preferences. It may look something like that.
 
 ```ruby
-# config/initializers/xyeger.rb
-Sidekiq::Logging.logger.formatter = Xyeger::Formatters::SidekiqJson.new
+module API
+  module Helpers
+    module Logger
+      extend ActiveSupport::Concern
+
+      included do
+        logger.extend(Xyeger::Logger)
+        logger.formatter = Xyeger.config.formatter
+
+        use GrapeLogging::Middleware::RequestLogger,
+          logger: logger,
+          formatter: logger.formatter,
+          include: [
+            GrapeLogging::Loggers::Response.new,
+            GrapeLogging::Loggers::FilterParameters.new,
+            GrapeLogging::Loggers::ClientEnv.new
+          ]
+      end
+    end
+  end
+end
 ```
 
-## TaggedLogging example
+So inside your application you just include `API::Helpers::Logger`
 
 ```ruby
-Rails.logger.tagged('main', 'object_id') { Rails.logger.info('Message text', { id: 33 }) }
+module API
+  class Root < Grape::API
+    include API::Helpers::Logger
+  end
+end
 ```
-```json
-{
-  "pid" : 9210,
-  "app" : "Cryptopay",
-  "env" : "development",
-  "level" : "INFO",
-  "time" : "2017-07-18T19:42:53.373+03:00",
-  "message" : "Message text",
-  "context" : {
-    "id" : 33
-  },
-  "tags" : [
-    "main",
-    "object_id"
-  ]
-}
+
+### Sidekiq
+Sidekiq integration is really useful too. It store `fid` inside job and you can track logs even for retries. You don't have to do anything extra.
+
+### Sentry
+Sentry integration is hardcoded inside gem. So when you add anything inside context of Xyeger, it also means that you add something to Sentry context.
+
+### Plain ruby app
+For plain ruby application you have implement several steps:
+
+```ruby
+# Configure your Xyeger
+Xyeger.configure {}
+
+# Create instance of some logger
+logger = Logger.new(STDOUT)
+
+# Extend your logger with Xyeger::Logger
+logger.extend(Xyeger::Logger)
+
+# You are ready to go
+logger.info('Some message')
 ```
 
 
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

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

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "xyeger"
+require 'bundler/setup'
+require 'xyeger'
 
 # 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.
@@ -10,5 +10,5 @@ require "xyeger"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/xyeger/config.rb

@@ -1,21 +1,17 @@
 module Xyeger
   class Config
-    attr_accessor :output,
-                  :formatter,
-                  :filter_parameters,
-                  :filter,
-                  :hostname,
-                  :app,
-                  :env
+    attr_accessor :output, :formatter, :hostname, :app, :env, :context_resolver, :message_resolver
+    attr_reader :context
 
     def initialize
       @output = STDOUT
       @formatter = Xyeger::Formatters::Json.new
-      @filter_parameters = Rails.application.config.filter_parameters
-
-      @hostname = ENV['XYEGER_HOSTNAME']
-      @app = Rails.application.class.parent_name
-      @env = Rails.env
+      @hostname = ENV['XYEGER_HOSTNAME'] || ''
+      @app = ENV['XYEGER_APPNAME'] || ''
+      @env = ENV['XYEGER_ENV'] || ''
+      @context = Xyeger::Context
+      @context_resolver = Xyeger::ContextResolver
+      @message_resolver = Xyeger::MessageResolver
     end
   end
 end

data/lib/xyeger/context.rb

@@ -0,0 +1,19 @@
+module Xyeger
+  class Context
+    def self.current
+      Thread.current[:xyeger_context] ||= {}
+    end
+
+    def self.clear_context
+      Thread.current[:xyeger_context] = nil
+    end
+
+    def self.add_context(context = {})
+      return unless context
+      context = Xyeger.config.context_resolver.call(context)
+      ::Raven.tags_context(context) if defined?(::Raven)
+      Thread.current[:xyeger_context] ||= {}
+      Thread.current[:xyeger_context].merge!(context || {})
+    end
+  end
+end

data/lib/xyeger/context_resolver.rb

@@ -0,0 +1,12 @@
+module Xyeger
+  class ContextResolver
+    def self.call(value)
+      case value
+      when Hash
+        value
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/xyeger/formatters/base.rb

@@ -5,23 +5,30 @@ module Xyeger
 
       UNCOLORIZE_REGEXP = /\e\[([;\d]+)?m/
 
-      attr_reader :attributes, :colors
+      attr_reader :attributes
 
       def initialize(attributes = {})
         @attributes = attributes
         @tags = []
-        @colors = Array.new(9) { Paint.random } if attributes[:colored]
       end
 
       def call(severity, timestamp, context, message)
-        message, context = prepare(message, context)
-        message = uncolorize(message) unless attributes[:colored]
+        message = uncolorize(message)
 
-        context = filter_context(context)
+        result = prepare(severity, timestamp, context, message)
+        result[:tags] = current_tags if current_tags.any?
+
+        if attributes[:except]&.any?
+          result.except(*attributes[:except])
+        else
+          result
+        end
+      end
 
-        result = {
+      def prepare(severity, timestamp, context, message)
+        {
           hostname: Xyeger.config.hostname,
-          pid: $$,
+          pid: $$, # rubocop:disable Style/SpecialGlobalVars
           app: Xyeger.config.app,
           env: Xyeger.config.env,
           level: severity,
@@ -29,39 +36,6 @@ module Xyeger
           message: message,
           context: context
         }
-
-        result[:tags] = current_tags if current_tags.any?
-        colored(result) if attributes[:colored]
-
-        result
-      end
-
-      private def prepare(message, context)
-        new_message = attributes[:message].call(message, context) if attributes[:message]
-        new_context = attributes[:context].call(message, context) if attributes[:context]
-
-        return [new_message, new_context] if attributes[:message] || attributes[:context]
-
-        case message
-        when LogrageRaw
-          ['Lograge', message.data]
-        when ::StandardError
-          ['StandardError', { class: message.class.name, error: message.to_s }]
-        else
-          [message.to_s, context]
-        end
-      end
-
-      private def colored(result)
-        result.each_with_index do |(key, value), index|
-          result[key] = Paint[value, colors[index]]
-        end
-      end
-
-      private def filter_context(context)
-        return context unless Xyeger.config.filter && context.is_a?(Hash)
-
-        Xyeger.config.filter.filter(context)
       end
 
       def uncolorize(message)

data/lib/xyeger/formatters/json.rb

@@ -1,9 +1,10 @@
+require 'json'
+
 module Xyeger
   module Formatters
     class Json < Base
       def call(*args)
         result = super(*args)
-
         result.compact.to_json + "\n"
       end
     end

data/lib/xyeger/formatters/text.rb

@@ -0,0 +1,20 @@
+module Xyeger
+  module Formatters
+    class Text < Base
+      def call(*args)
+        result = super(*args)
+        arr = []
+        arr << "[#{result[:time]}]"
+        arr << "[#{result[:level]}]".ljust(8)
+
+        context = result[:context]
+        arr << "[#{context[:fid]}] " if context[:fid]
+
+        arr << context.except(:fid).map { |k, v| "#{k}=#{v}" }.join(' ')
+        arr << result[:message]
+
+        "#{arr.join(' ').gsub(/ +/, ' ')}\n"
+      end
+    end
+  end
+end

data/lib/xyeger/formatters/values.rb

@@ -4,7 +4,7 @@ module Xyeger
       def call(*args)
         result = super(*args)
 
-        result.values.join(' ') + "\n"
+        result.values.join(' ').gsub(/ +/, ' ') + "\n"
       end
     end
   end

data/lib/xyeger/formatters.rb

@@ -1,11 +1,4 @@
-module Xyeger
-  module Formatters
-    extend ActiveSupport::Autoload
-
-    autoload :Base
-    autoload :Json
-    autoload :Values
-    autoload :LogrageRaw
-    autoload :SidekiqJson
-  end
-end
+require 'xyeger/formatters/base'
+require 'xyeger/formatters/json'
+require 'xyeger/formatters/text'
+require 'xyeger/formatters/values'

data/lib/xyeger/integrations/rails.rb

@@ -0,0 +1,35 @@
+require 'rails'
+
+module Xyeger
+  module Rails
+    class FlowIdMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        fid = request.request_id || SecureRandom.uuid
+        Xyeger.add_context(fid: fid)
+        @app.call(env)
+      end
+    end
+  end
+
+  class Railtie < ::Rails::Railtie
+    initializer 'xyeger.configure_rails_initialization' do |app|
+      app.config.middleware.insert_after(
+        ActionDispatch::RequestId, Xyeger::Middlewares::ClearContext
+      )
+      app.config.middleware.insert_after(
+        ActionDispatch::RequestId, Xyeger::Rails::FlowIdMiddleware
+      )
+    end
+
+    config.after_initialize do
+      ::Rails.logger = ActiveSupport::Logger.new(STDOUT)
+      ::Rails.logger.extend(Xyeger::Logger)
+      ::ActiveSupport.on_load(:action_record) { self.logger = ::Rails.logger }
+    end
+  end
+end

data/lib/xyeger/integrations/sidekiq.rb

@@ -0,0 +1,38 @@
+require 'sidekiq'
+
+module Xyeger
+  module Sidekiq
+    module LoggingPatch
+      def with_job_hash_context(job_hash)
+        # If we're using a wrapper class, like ActiveJob, use the 'wrapped'
+        # attribute to expose the underlying thing.
+        klass = job_hash['wrapped'] || job_hash['class']
+        jid = job_hash['jid']
+        fid = job_hash['fid'] || Xyeger.context.current[:fid] || SecureRandom.uuid
+
+        Xyeger.add_context(worker: klass, fid: fid, jid: jid)
+
+        yield
+      ensure
+        Xyeger.clear_context
+      end
+    end
+
+    class FlowIdMiddleware
+      def call(_worker_class, msg, _queue, _redis_pool)
+        msg['fid'] = Xyeger.context.current[:fid]
+        yield
+      end
+    end
+  end
+end
+
+::Sidekiq.logger = Rails.logger
+
+::Sidekiq::Logging.singleton_class.prepend(Xyeger::Sidekiq::LoggingPatch)
+
+::Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add(Xyeger::Sidekiq::FlowIdMiddleware)
+  end
+end

data/lib/xyeger/logger.rb

@@ -1,24 +1,24 @@
 module Xyeger
   module Logger
     def self.extended(base)
-      base.formatter = Xyeger.config.formatter if Xyeger.config
+      base.formatter = Xyeger.config.formatter
     end
 
-    ActiveSupport::Logger::Severity.constants.each do |severity|
-      define_method severity.downcase do |message=nil, context=nil, &block|
-        context, message = message, context if message.is_a?(Hash)
-
-        if block
-          result = block.call
+    def add(severity, message = nil, progname = nil, &block)
+      message = prepare(message, progname, &block)
+      super(severity, message, Xyeger.context.current)
+    end
 
-          if result.is_a?(Hash)
-            context = result
-          else
-            message = result
-          end
+    def prepare(message, progname, &block)
+      if message.nil?
+        if block_given?
+          message = yield(block)
+        else
+          message = progname
+          progname = nil
         end
-        add(ActiveSupport::Logger::Severity.const_get(severity), message, context)
       end
+      Xyeger.config.message_resolver.call(message, progname)
     end
   end
 end

data/lib/xyeger/message_resolver.rb

@@ -0,0 +1,14 @@
+module Xyeger
+  class MessageResolver
+    def self.call(message, progname)
+      message =
+        case message
+        when ::StandardError
+          [message.class.name, message].compact.join(' ')
+        else
+          message.to_s
+        end
+      [progname, message].compact.join(' ')
+    end
+  end
+end

data/lib/xyeger/middlewares/clear_context.rb

@@ -0,0 +1,15 @@
+module Xyeger
+  module Middlewares
+    class ClearContext
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        Xyeger.clear_context
+      end
+    end
+  end
+end

data/lib/xyeger/version.rb

@@ -1,3 +1,3 @@
 module Xyeger
-  VERSION = '0.3.4'.freeze
+  VERSION = '1.0.0.rc'.freeze
 end

data/lib/xyeger.rb

@@ -1,48 +1,30 @@
-require 'active_support/logger'
 require 'active_support/tagged_logging'
-require 'active_support/dependencies/autoload'
-require 'active_support/ordered_options'
-require 'paint'
-require 'lograge'
+require 'forwardable'
 require 'xyeger/version'
+require 'xyeger/config'
+require 'xyeger/context'
+require 'xyeger/context_resolver'
+require 'xyeger/message_resolver'
+require 'xyeger/formatters'
+require 'xyeger/logger'
+require 'xyeger/middlewares/clear_context'
+require 'xyeger/integrations/rails' if defined?(::Rails)
+require 'xyeger/integrations/sidekiq' if defined?(::Sidekiq)
 
 module Xyeger
   module_function
 
-  extend ActiveSupport::Autoload
-
-  autoload :Config
-  autoload :Logger
-  autoload :Formatters
-
   class << self
     attr_reader :config
+    extend Forwardable
 
     def configure
-      @config ||= Xyeger::Config.new()
-
+      @config ||= Xyeger::Config.new
       yield(@config)
-
-      if @config.filter_parameters
-        @config.filter ||= ActionDispatch::Http::ParameterFilter.new(@config.filter_parameters)
-      end
-      Xyeger.setup
-    end
-  end
-
-  def setup
-    app = Rails.application
-    setup_lograge(app)
-
-    Rails.logger.extend(Logger)
-  end
-
-  def setup_lograge(app)
-    app.config.lograge.formatter = -> (data) { Formatters::LogrageRaw.new(data: data) }
-    app.config.lograge.custom_options = lambda do |event|
-      { params: event.payload[:params]&.except('controller', 'action', 'format', 'id') }
     end
 
-    Lograge.setup(app)
+    def_delegator :config, :context
+    def_delegator :context, :add_context
+    def_delegator :context, :clear_context
   end
 end

data/xyeger.gemspec

@@ -5,10 +5,10 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'xyeger/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "xyeger"
+  spec.name          = 'xyeger'
   spec.version       = Xyeger::VERSION
-  spec.authors       = ["Avramov Vsevolod"]
-  spec.email         = ["vsevolod@cryptopay.me"]
+  spec.authors       = ['Avramov Vsevolod']
+  spec.email         = ['vsevolod@cryptopay.me']
 
   spec.summary       = 'Uniq logger for project'
   spec.description   = 'Uniq logger for project'
@@ -20,26 +20,23 @@ Gem::Specification.new do |spec|
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
   end
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency 'lograge', '>= 0.4'
-  spec.add_dependency 'paint', '~> 2.0'
+  spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'activesupport', '>= 4'
   spec.add_runtime_dependency 'actionpack', '>= 4'
   spec.add_runtime_dependency 'railties', '>= 4'
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop'
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: xyeger
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 1.0.0.rc
 platform: ruby
 authors:
 - Avramov Vsevolod
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-18 00:00:00.000000000 Z
+date: 2017-08-09 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: lograge
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: paint
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -144,8 +116,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- CODE_OF_CONDUCT.md
+- ".rubocop.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -153,14 +126,18 @@ files:
 - bin/setup
 - lib/xyeger.rb
 - lib/xyeger/config.rb
+- lib/xyeger/context.rb
+- lib/xyeger/context_resolver.rb
 - lib/xyeger/formatters.rb
 - lib/xyeger/formatters/base.rb
 - lib/xyeger/formatters/json.rb
-- lib/xyeger/formatters/key_value.rb
-- lib/xyeger/formatters/lograge_raw.rb
-- lib/xyeger/formatters/sidekiq_json.rb
+- lib/xyeger/formatters/text.rb
 - lib/xyeger/formatters/values.rb
+- lib/xyeger/integrations/rails.rb
+- lib/xyeger/integrations/sidekiq.rb
 - lib/xyeger/logger.rb
+- lib/xyeger/message_resolver.rb
+- lib/xyeger/middlewares/clear_context.rb
 - lib/xyeger/version.rb
 - xyeger.gemspec
 homepage: https://github.com/vsevolod/xyeger
@@ -179,12 +156,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Uniq logger for project

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at vsevolod@cryptopay.me. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

data/lib/xyeger/formatters/key_value.rb

@@ -1,11 +0,0 @@
-module Xyeger
-  module Formatters
-    class KeyValue < Base
-      def call(*args)
-        result = super(*args)
-
-        result.compact.to_json + "\n"
-      end
-    end
-  end
-end

data/lib/xyeger/formatters/lograge_raw.rb

@@ -1,6 +0,0 @@
-module Xyeger
-  module Formatters
-    class LogrageRaw < ActiveSupport::OrderedOptions
-    end
-  end
-end

data/lib/xyeger/formatters/sidekiq_json.rb

@@ -1,26 +0,0 @@
-module Xyeger
-  module Formatters
-    class SidekiqJson < Base
-      def call(severity, timestamp, context, message)
-        context, message = prepare_message(message) unless context
-
-        super(severity, timestamp, context, message).merge(
-          tid: "TID-#{Thread.current.object_id.to_s(36)}",
-          sidekiq_context: sidekiq_context
-        ).to_json + "\n"
-      end
-
-      def sidekiq_context
-        c = Thread.current[:sidekiq_context]
-        c.join(' ') if c&.any?
-      end
-
-      def prepare_message(message)
-        json = JSON.parse(message)
-        [filter_context(json), 'Sidekiq']
-      rescue JSON::ParserError => e
-        [nil, message]
-      end
-    end
-  end
-end