lenjador 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b22b9348f98f915eaa67dec7cbbe762d09f86dc
+  data.tar.gz: 2e22ff6de0251d2e007b83e626e14c20d860b281
+SHA512:
+  metadata.gz: e48ff7741f76c07e5dd00e910e32cd6013ee4ff6854ccfc29bf4dc249e54635500c4ff5fedd51ac7394a643baa4a6e1a60269b41b9c5fb2006110fefe45f13af
+  data.tar.gz: 0cd79d4f685890c86d4c0c182f256f35c0dbe48a95b77a548193cbec05f21a8df5ce551c1fd77fe5a9a751a5a9491b04c24e78392c9bb7ae7fa92ea2f272ae29

data/.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+npm-debug.log
+Gemfile.lock
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+logasm

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.4.1

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - jruby

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+group :test, :development do
+  gem 'pry'
+  gem 'rspec'
+end
+
+gemspec

data/README.md

@@ -0,0 +1,121 @@
+Lenjador
+================
+
+## Usage
+
+### Creating a new Lenjador logger in Ruby
+
+```ruby
+Lenjador.build(application_name, logger_config)
+```
+
+<b>logger_config</b> is a hash with logger types and their configuration.
+
+#### Configuration
+
+```
+loggers:
+  stdout:
+    level: 'debug'
+```
+Supported log levels:
+
+1. fatal
+2. error
+3. warn
+4. info
+5. debug
+
+For example level: 'warn' will log everything with warn and above.
+
+#### Examples
+
+Creating a new stdout logger
+
+```ruby
+require 'lenjador'
+
+lenjador = Lenjador.build('myApp', stdout: nil)
+```
+
+When no loggers are specified, it creates a stdout logger by default.
+
+## Preprocessors
+
+Preprocessors allow modification of log messages, prior to sending of the message to the configured logger(s).
+
+### Blacklist
+
+Excludes or masks defined fields of the passed hash object.
+You can specify the name of the field and which action to take on it.
+Nested hashes of any level are preprocessed as well.
+
+Available actions:
+
+* `prune` (default) - fully excludes the field and its value from the hash.
+* `mask` - replaces every character from the original value with `*`. 
+  In case of `array`, `hash` or `boolean` value is replaced with one `*`.
+
+#### Configuration
+
+```yaml
+preprocessors:
+  blacklist:
+    fields:
+      - key: password
+      - key: phone
+    action: mask
+```
+
+#### Usage
+
+```ruby
+logger = Lenjador.build(application_name, logger_config, preprocessors)
+
+input = {password: 'password', info: {phone: '+12055555555'}}
+
+logger.debug("Received request", input)
+```
+
+Logger output:
+
+```
+Received request {"info":{"phone":"************"}}
+```
+
+### Whitelist
+
+Prunes or masks all the fields except those whitelisted in the configuration using [JSON Pointer](https://tools.ietf.org/html/rfc6901).
+Only simple values(`string`, `number`, `boolean`) can be whitelisted.
+Whitelisting array and hash elements can be done using wildcard symbol `~`.
+
+Available actions:
+
+* `mask` (default) - replaces every character from the original value with `*`. 
+  In case of `array`, `hash` or `boolean` value is replaced with one `*`.
+* `prune` - fully excludes the field and its value from the hash.
+
+#### Configuration
+
+```yaml
+preprocessors:
+  whitelist:
+    pointers: ['/info/phone', '/addresses/~/host']
+  action: prune
+```
+
+#### Usage
+
+```ruby
+logger = Lenjador.build(application_name, logger_config, preprocessors)
+
+input = {password: 'password', info: {phone: '+12055555555'}, addresses: [{host: 'example.com', path: 'info'}]}
+
+logger.debug("Received request", input)
+```
+
+Logger output:
+
+```
+Received request {password: "********", "info": {"phone": "+12055555555"}, "addresses": [{"host": "example.com","path": "****"}]}
+```

data/Rakefile

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

data/benchmark/whitelisting.rb

@@ -0,0 +1,53 @@
+require 'bundler/setup'
+require 'lenjador/preprocessors/whitelist'
+require 'benchmark/ips'
+
+pointers = %w[
+  /scalar
+  /flat_hash/~
+  /nested_hash/~/deep_hash/~
+  /flat_array/~
+  /nested_array/~/deep_array/~
+]
+
+%w[prune mask].each do |action|
+  preprocessor = Lenjador::Preprocessors::Whitelist.new(pointers: pointers, action: action)
+
+  Benchmark.ips do |x|
+    x.config(time: 5, warmup: 2)
+
+    x.report("Scalar value whitelisting (action=#{action})") do
+      preprocessor.process(scalar: 'value', bad_scalar: 'value', hash: {})
+    end
+
+    x.report("Flat hash whitelisting (action=#{action})") do
+      preprocessor.process(flat_hash: { scalar: 'value', array: [1, 2], hash: {} })
+    end
+
+    x.report("Nested hash whitelisting (action=#{action})") do
+      preprocessor.process(
+        nested_hash: {
+          next_level_hash: {
+            deep_hash: { scalar: 'value', array: [1, 2] }
+          },
+          next_level_hash2: {
+            deep_hash: { scalar: 'value', array: [1, 2] }
+          },
+          next_level_hash3: {
+            deep_hash: { scalar: 'value', array: [1, 2] }
+          }
+        }
+      )
+    end
+
+    x.report("Flat array whitelisting (action=#{action})") do
+      preprocessor.process(
+        nested_array: [
+          { deep_array: [1, 2, 3] },
+          { deep_array: [1, 2, 3] },
+          { deep_array: [1, 2, 3] }
+        ]
+      )
+    end
+  end
+end

data/lenjador.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  if RUBY_PLATFORM =~ /java/
+    gem.name = 'lenjador-jruby'
+  else
+    gem.name = 'lenjador'
+  end
+
+  gem.version       = '1.2.1'
+  gem.authors       = ["Salemove"]
+  gem.email         = ["support@salemove.com"]
+  gem.description   = %q{It's lenjadoric}
+  gem.summary       = %q{What description said}
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'lru_redux'
+
+  if RUBY_PLATFORM =~ /java/
+    gem.add_dependency 'jrjackson'
+  else
+    gem.add_dependency 'oj'
+  end
+
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "bunny"
+  gem.add_development_dependency "benchmark-ips"
+end

data/lib/lenjador/adapters/stdout_adapter.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+
+class Lenjador
+  module Adapters
+    class StdoutAdapter
+      extend Forwardable
+
+      attr_reader :logger
+
+      def_delegators :@logger, :debug?, :info?, :warn?, :error?, :fatal?
+
+      def initialize(level, *)
+        @logger = Logger.new(STDOUT)
+        @logger.level = level
+      end
+
+      def log(level, metadata = {})
+        message = metadata[:message]
+        data = metadata.select { |key, value| key != :message }
+        log_data = [
+          message,
+          data.empty? ? nil : Utils.generate_json(data)
+        ].compact.join(' ')
+
+        @logger.public_send level, log_data
+      end
+    end
+  end
+end

data/lib/lenjador/adapters/stdout_json_adapter.rb

@@ -0,0 +1,60 @@
+class Lenjador
+  module Adapters
+    class StdoutJsonAdapter
+      def initialize(level, service_name, *)
+        @level = level
+        @service_name = service_name
+        @application_name = Utils.application_name(service_name)
+        @mutex = Mutex.new if RUBY_ENGINE == "jruby"
+      end
+
+      def log(level, metadata = {})
+        if meets_threshold?(level)
+          message = Utils.build_event(metadata, level, @application_name)
+          print_line(Utils.generate_json(message))
+        end
+      end
+
+      def debug?
+        meets_threshold?(:debug)
+      end
+
+      def info?
+        meets_threshold?(:info)
+      end
+
+      def warn?
+        meets_threshold?(:warn)
+      end
+
+      def error?
+        meets_threshold?(:error)
+      end
+
+      def fatal?
+        meets_threshold?(:fatal)
+      end
+
+      private
+
+      def meets_threshold?(level)
+        LOG_LEVELS.index(level.to_s) >= @level
+      end
+
+      # puts is atomic in MRI starting from 2.5.0
+      if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.5.0"
+        def print_line(str)
+          $stdout.puts(str)
+        end
+      elsif RUBY_ENGINE == "jruby"
+        def print_line(str)
+          @mutex.synchronize { $stdout.write(str + "\n") }
+        end
+      else
+        def print_line(str)
+          $stdout.write(str + "\n")
+        end
+      end
+    end
+  end
+end

data/lib/lenjador/adapters.rb

@@ -0,0 +1,22 @@
+class Lenjador
+  module Adapters
+    LOG_LEVELS = %w(debug info warn error fatal unknown).freeze
+
+    def self.get(type, service_name, arguments)
+      adapter =
+        if type == 'stdout'
+          if arguments.fetch(:json, false)
+            require_relative 'adapters/stdout_json_adapter'
+            StdoutJsonAdapter
+          else
+            require_relative 'adapters/stdout_adapter'
+            StdoutAdapter
+          end
+        else
+          raise "Unsupported logger: #{type}"
+        end
+      level = LOG_LEVELS.index(arguments.fetch(:level, 'debug'))
+      adapter.new(level, service_name, arguments)
+    end
+  end
+end

data/lib/lenjador/null_logger.rb

@@ -0,0 +1,18 @@
+class Lenjador
+  class NullLogger
+    def debug(*)
+    end
+
+    def info(*)
+    end
+
+    def warn(*)
+    end
+
+    def error(*)
+    end
+
+    def fatal(*)
+    end
+  end
+end

data/lib/lenjador/preprocessors/blacklist.rb

@@ -0,0 +1,61 @@
+class Lenjador
+  module Preprocessors
+    class Blacklist
+
+      DEFAULT_ACTION = 'prune'
+      MASK_SYMBOL = '*'
+      MASKED_VALUE = MASK_SYMBOL * 5
+
+      class UnsupportedActionException < Exception
+      end
+
+      def initialize(config = {})
+        @fields_to_process = config[:fields].inject({}) do |mem, field|
+          key = field.delete(:key)
+          options = {action: DEFAULT_ACTION}.merge(field)
+          validate_action_supported(options[:action])
+          mem.merge(key => options)
+        end
+      end
+
+      def process(data)
+        if data.is_a? Hash
+          data.inject({}) do |mem, (key, val)|
+            if (field = @fields_to_process[key.to_s])
+              self.send(action_method(field[:action]), mem, key, val)
+            else
+              mem.merge(key => process(val))
+            end
+          end
+        elsif data.is_a? Array
+          data.inject([]) do |mem, val|
+            mem + [process(val)]
+          end
+        else
+          data
+        end
+      end
+
+      private
+
+      def action_method(action)
+        "#{action}_field"
+      end
+
+      def validate_action_supported(action)
+        unless self.respond_to?(action_method(action).to_sym, true)
+          raise UnsupportedActionException.new("Action: #{action} is not supported")
+        end
+      end
+
+      def mask_field(data, key, val)
+        data.merge(key => MASKED_VALUE)
+      end
+
+      def prune_field(data, *)
+        data
+      end
+      alias_method :exclude_field, :prune_field
+    end
+  end
+end

data/lib/lenjador/preprocessors/json_pointer_trie.rb

@@ -0,0 +1,40 @@
+require 'lru_redux'
+
+class Lenjador
+  module Preprocessors
+    class JSONPointerTrie
+      SEPARATOR = '/'.freeze
+      WILDCARD = '~'.freeze
+      DEFAULT_CACHE_SIZE = 100
+
+      def initialize(cache_size: DEFAULT_CACHE_SIZE, **)
+        @root_node = {}
+        @cache = LruRedux::Cache.new(cache_size)
+      end
+
+      def insert(pointer)
+        split_path(pointer).reduce(@root_node) do |tree, key|
+          tree[key] ||= {}
+        end
+
+        self
+      end
+
+      def include?(path)
+        @cache.getset(path) { traverse_path(path) }
+      end
+
+      private
+
+      def traverse_path(path)
+        split_path(path).reduce(@root_node) do |node, key|
+          node[key] || node[WILDCARD] || (break false)
+        end
+      end
+
+      def split_path(path)
+        path.split(SEPARATOR).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/lenjador/preprocessors/strategies/mask.rb

@@ -0,0 +1,43 @@
+class Lenjador
+  module Preprocessors
+    module Strategies
+      class Mask
+        MASK_SYMBOL = '*'.freeze
+        MASKED_VALUE = MASK_SYMBOL * 5
+
+        def initialize(trie)
+          @trie = trie
+        end
+
+        def process(data, pointer = '')
+          return MASKED_VALUE unless @trie.include?(pointer)
+
+          case data
+          when Hash
+            process_hash(data, pointer)
+
+          when Array
+            process_array(data, pointer)
+
+          else
+            data
+          end
+        end
+
+        private
+
+        def process_hash(data, parent_pointer)
+          data.each_with_object({}) do |(key, value), result|
+            result[key] = process(value, "#{parent_pointer}/#{key}")
+          end
+        end
+
+        def process_array(data, parent_pointer)
+          data.each_with_index.map do |value, index|
+            process(value, "#{parent_pointer}/#{index}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lenjador/preprocessors/strategies/prune.rb

@@ -0,0 +1,44 @@
+class Lenjador
+  module Preprocessors
+    module Strategies
+      class Prune
+        def initialize(trie)
+          @trie = trie
+        end
+
+        def process(data, pointer = '')
+          return nil unless @trie.include?(pointer)
+
+          case data
+          when Hash
+            process_hash(data, pointer)
+
+          when Array
+            process_array(data, pointer)
+
+          else
+            data
+          end
+        end
+
+        private
+
+        def process_hash(data, parent_pointer)
+          data.each_with_object({}) do |(key, value), result|
+            path = "#{parent_pointer}/#{key}"
+
+            result[key] = process(value, path) if @trie.include?(path)
+          end
+        end
+
+        def process_array(data, parent_pointer)
+          data.each_with_index.each_with_object([]) do |(value, index), result|
+            path = "#{parent_pointer}/#{index}"
+
+            result << process(value, path) if @trie.include?(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lenjador/preprocessors/whitelist.rb

@@ -0,0 +1,56 @@
+require 'lenjador/preprocessors/json_pointer_trie'
+require 'lenjador/preprocessors/strategies/mask'
+require 'lenjador/preprocessors/strategies/prune'
+
+class Lenjador
+  module Preprocessors
+    class Whitelist
+      DEFAULT_WHITELIST = %w[/id /message /correlation_id /queue].freeze
+      MASK_SYMBOL = '*'.freeze
+      MASKED_VALUE = MASK_SYMBOL * 5
+
+      PRUNE_ACTION_NAMES = %w[prune exclude].freeze
+
+      class InvalidPointerFormatException < Exception
+      end
+
+      def initialize(config = {})
+        trie = build_trie(config)
+
+        @strategy = if PRUNE_ACTION_NAMES.include?(config[:action].to_s)
+                      Strategies::Prune.new(trie)
+                    else
+                      Strategies::Mask.new(trie)
+                    end
+      end
+
+      def process(data)
+        @strategy.process(data)
+      end
+
+      private
+
+      def validate_pointer(pointer)
+        if pointer.slice(-1) == '/'
+          raise InvalidPointerFormatException, 'Pointer should not contain trailing slash'
+        end
+      end
+
+      def decode(pointer)
+        pointer
+          .gsub('~1', '/')
+          .gsub('~0', '~')
+      end
+
+      def build_trie(config)
+        pointers = (config[:pointers] || []) + DEFAULT_WHITELIST
+
+        pointers.reduce(JSONPointerTrie.new(config)) do |trie, pointer|
+          validate_pointer(pointer)
+
+          trie.insert(decode(pointer))
+        end
+      end
+    end
+  end
+end

data/lib/lenjador/preprocessors.rb

@@ -0,0 +1,18 @@
+class Lenjador
+  module Preprocessors
+    def self.get(type, arguments)
+      preprocessor =
+        case type.to_s
+        when 'blacklist'
+          require_relative 'preprocessors/blacklist'
+          Preprocessors::Blacklist
+        when 'whitelist'
+          require_relative 'preprocessors/whitelist'
+          Preprocessors::Whitelist
+        else
+          raise "Unknown preprocessor: #{type}"
+        end
+      preprocessor.new(arguments)
+    end
+  end
+end