logasm-jruby 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d979fabe79cb012160eae9358e7ebb15122ee58715d36c2d19d3a983413f1962
+  data.tar.gz: fd5391fc22692e4a82528bc43863a9ce4a93fa854e0826fcfb56371c0b6c178d
+SHA512:
+  metadata.gz: 575d5e5f7ea14be165321542d33561d8405be7b3b653f22c3a88e6be359a29fcf4916ce0c0fbe6a2324edd02e7c659a3f8d663ffef6f79cdbfedc0c356a63fba
+  data.tar.gz: a9b53672c3b49f420fe55327fdd1ece358580cb6787ae0bfddddcaa98cb6f076b0ab4d72d814b010f0a0494299214c1513ba5fa0bf8cadd6aec096febfa1873e

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,6 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.3
+  - 2.4
+  - 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 @@
+Logasm
+================
+
+## Usage
+
+### Creating a new Logasm logger in Ruby
+
+```ruby
+Logasm.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 'logasm'
+
+logasm = Logasm.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 = Logasm.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 = Logasm.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 'logasm/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 = Logasm::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/lib/logasm.rb

@@ -0,0 +1,74 @@
+require 'logger'
+require_relative 'logasm/adapters'
+require_relative 'logasm/utils'
+require_relative 'logasm/null_logger'
+require_relative 'logasm/preprocessors'
+
+LOG_LEVEL_QUERY_METHODS = [:debug?, :info?, :warn?, :error?, :fatal?]
+
+class Logasm
+  def self.build(service_name, loggers_config, preprocessors_config = {})
+    loggers_config ||= {stdout: nil}
+    preprocessors = preprocessors_config.map do |type, arguments|
+      Preprocessors.get(type.to_s, arguments || {})
+    end
+    adapters = loggers_config.map do |type, arguments|
+      Adapters.get(type.to_s, service_name, arguments || {})
+    end
+    new(adapters, preprocessors)
+  end
+
+  def initialize(adapters, preprocessors)
+    @adapters = adapters
+    @preprocessors = preprocessors
+  end
+
+  def debug(*args, &block)
+    log :debug, *args, &block
+  end
+
+  def info(*args, &block)
+    log :info, *args, &block
+  end
+
+  def warn(*args, &block)
+    log :warn, *args, &block
+  end
+
+  def error(*args, &block)
+    log :error, *args, &block
+  end
+
+  def fatal(*args, &block)
+    log :fatal, *args, &block
+  end
+
+  LOG_LEVEL_QUERY_METHODS.each do |method|
+    define_method(method) do
+      @adapters.any? {|adapter| adapter.public_send(method) }
+    end
+  end
+
+  private
+
+  def log(level, *args, &block)
+    data = parse_log_data(*args, &block)
+    processed_data = preprocess(data)
+
+    @adapters.each do |adapter|
+      adapter.log(level, processed_data)
+    end
+  end
+
+  def preprocess(data)
+    @preprocessors.inject(data) do |data_to_process, preprocessor|
+      preprocessor.process(data_to_process)
+    end
+  end
+
+  def parse_log_data(message = nil, metadata = {}, &block)
+    return message if message.is_a?(Hash)
+
+    (metadata || {}).merge(message: block ? block.call : message)
+  end
+end

data/lib/logasm/adapters.rb

@@ -0,0 +1,22 @@
+class Logasm
+  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/logasm/adapters/stdout_adapter.rb

@@ -0,0 +1,29 @@
+require 'forwardable'
+
+class Logasm
+  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/logasm/adapters/stdout_json_adapter.rb

@@ -0,0 +1,44 @@
+class Logasm
+  module Adapters
+    class StdoutJsonAdapter
+      def initialize(level, service_name, *)
+        @level = level
+        @service_name = service_name
+        @application_name = Utils.application_name(service_name)
+      end
+
+      def log(level, metadata = {})
+        if meets_threshold?(level)
+          message = Utils.build_event(metadata, level, @application_name)
+          STDOUT.puts(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
+    end
+  end
+end

data/lib/logasm/null_logger.rb

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

data/lib/logasm/preprocessors.rb

@@ -0,0 +1,18 @@
+class Logasm
+  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

data/lib/logasm/preprocessors/blacklist.rb

@@ -0,0 +1,61 @@
+class Logasm
+  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