lenjador 1.2.1

data/lib/lenjador/utils.rb

@@ -0,0 +1,91 @@
+require 'time'
+
+class Lenjador
+  module Utils
+    DECIMAL_FRACTION_OF_SECOND = 3
+
+    # Build logstash json compatible event
+    #
+    # @param [Hash] metadata
+    # @param [#to_s] level
+    # @param [String] service_name
+    #
+    # @return [Hash]
+    def self.build_event(metadata, level, application_name)
+      overwritable_params
+        .merge(metadata)
+        .merge(
+          application: application_name,
+          level: level
+        )
+    end
+
+    # Return application name
+    #
+    # Returns lower snake case application name. This allows the
+    # application value to be used in the elasticsearch index name.
+    #
+    # @param [String] service_name
+    #
+    # @return [String]
+    def self.application_name(service_name)
+      underscore(service_name)
+    end
+
+    def self.overwritable_params
+      {
+        :@timestamp => Time.now.utc.iso8601(DECIMAL_FRACTION_OF_SECOND)
+      }
+    end
+
+    def self.serialize_time_objects!(object)
+      if object.is_a?(Hash)
+        object.each do |key, value|
+          object[key] = serialize_time_objects!(value)
+        end
+      elsif object.is_a?(Array)
+        object.each_index do |index|
+          object[index] = serialize_time_objects!(object[index])
+        end
+      elsif object.is_a?(Time) || object.is_a?(Date)
+        object.iso8601
+      else
+        object
+      end
+    end
+
+    if RUBY_PLATFORM =~ /java/
+      require 'jrjackson'
+
+      DUMP_OPTIONS = {
+        timezone: 'utc',
+        date_format: "YYYY-MM-dd'T'HH:mm:ss.SSSX"
+      }.freeze
+
+      def self.generate_json(obj)
+        JrJackson::Json.dump(obj, DUMP_OPTIONS)
+      end
+    else
+      require 'oj'
+      DUMP_OPTIONS = { mode: :compat, time_format: :ruby }.freeze
+
+      def self.generate_json(obj)
+        serialize_time_objects!(obj)
+
+        Oj.dump(obj, DUMP_OPTIONS)
+      end
+    end
+
+    def self.underscore(input)
+      word = input.to_s.dup
+      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
+
+    private_class_method :overwritable_params
+  end
+end

data/lib/lenjador.rb

@@ -0,0 +1,74 @@
+require 'logger'
+require_relative 'lenjador/adapters'
+require_relative 'lenjador/utils'
+require_relative 'lenjador/null_logger'
+require_relative 'lenjador/preprocessors'
+
+LOG_LEVEL_QUERY_METHODS = [:debug?, :info?, :warn?, :error?, :fatal?]
+
+class Lenjador
+  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/spec/adapters/stdout_adapter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require_relative '../../lib/lenjador/adapters/stdout_adapter'
+
+describe Lenjador::Adapters::StdoutAdapter do
+  it 'creates a stdout logger' do
+    io_logger = described_class.new(0)
+
+    logger = io_logger.instance_variable_get(:@logger)
+    expect(logger).to be_a Logger
+  end
+
+  describe '#log' do
+    let(:adapter) { described_class.new(0) }
+    let(:logger) { adapter.logger }
+
+    context 'with only a message' do
+      it 'stringifies it correctly' do
+        expect(logger).to receive(:info).with('test')
+
+        adapter.log :info, message: 'test'
+      end
+    end
+
+    context 'with an empty message' do
+      it 'stringifies it correctly' do
+        expect(logger).to receive(:info).with(' {"a":"b"}')
+
+        adapter.log :info, message: '', a: 'b'
+      end
+    end
+
+    context 'with no message' do
+      it 'stringifies it correctly' do
+        expect(logger).to receive(:info).with('{"a":"b"}')
+
+        adapter.log :info, a: 'b'
+      end
+    end
+
+    context 'with a message and metadata' do
+      it 'stringifies it correctly' do
+        expect(logger).to receive(:info).with('test {"a":"b"}')
+
+        adapter.log :info, message: 'test', a: 'b'
+      end
+    end
+  end
+end

data/spec/adapters/stdout_json_adapter_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'json'
+require_relative '../../lib/lenjador/adapters/stdout_json_adapter'
+
+describe Lenjador::Adapters::StdoutJsonAdapter do
+  let(:debug_level_code) { 0 }
+  let(:debug_level) { Lenjador::Adapters::LOG_LEVELS[debug_level_code] }
+  let(:info_level_code) { 1 }
+  let(:info_level) { Lenjador::Adapters::LOG_LEVELS[info_level_code] }
+
+  let(:stdout) { StringIO.new }
+
+  around do |example|
+    old_stdout = $stdout
+    $stdout = stdout
+
+    begin
+      example.call
+    ensure
+      $stdout = old_stdout
+    end
+  end
+
+  describe '#log' do
+    context 'when below threshold' do
+      let(:adapter) { described_class.new(debug_level_code, service_name) }
+      let(:metadata) { {x: 'y'} }
+      let(:event) { {a: 'b', x: 'y'} }
+      let(:serialized_event) { JSON.dump(event) }
+      let(:service_name) { 'my-service' }
+      let(:application_name) { 'my_service' }
+
+      before do
+        allow(Lenjador::Utils).to receive(:build_event)
+          .with(metadata, info_level, application_name)
+          .and_return(event)
+      end
+
+      it 'sends serialized event to $stdout' do
+        adapter.log(info_level, metadata)
+        expect(output).to eq serialized_event + "\n"
+      end
+    end
+
+    context 'when above threshold' do
+      let(:adapter) { described_class.new(info_level_code, service_name) }
+      let(:metadata) { {x: 'y'} }
+      let(:service_name) { 'my-service' }
+
+      it 'does not log the event' do
+        adapter.log(debug_level, metadata)
+        expect(output).to be_empty
+      end
+    end
+  end
+
+  private
+
+  def output
+    stdout.string
+  end
+end

data/spec/lenjador_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Lenjador do
+  describe '.build' do
+    it 'creates stdout logger' do
+      expect(described_class).to receive(:new) do |adapters|
+        expect(adapters.count).to be(1)
+        expect(adapters.first).to be_a(described_class::Adapters::StdoutAdapter)
+      end
+
+      described_class.build('test_service', stdout: nil)
+    end
+
+    it 'creates stdout json logger' do
+      expect(described_class).to receive(:new) do |adapters|
+        expect(adapters.count).to be(1)
+        expect(adapters.first).to be_a(described_class::Adapters::StdoutJsonAdapter)
+      end
+
+      described_class.build('test_service', stdout: {json: true})
+    end
+
+    it 'creates stdout logger when no loggers are specified' do
+      expect(described_class).to receive(:new) do |adapters|
+        expect(adapters.count).to be(1)
+        expect(adapters.first).to be_a(described_class::Adapters::StdoutAdapter)
+      end
+
+      described_class.build('test_service', nil)
+    end
+
+    it 'creates preprocessor when preprocessor defined' do
+      expect(described_class).to receive(:new) do |adapters, preprocessors|
+        expect(preprocessors.count).to be(1)
+        expect(preprocessors.first).to be_a(described_class::Preprocessors::Blacklist)
+      end
+
+      preprocessors = {blacklist: {fields: []}}
+      described_class.build('test_service', nil, preprocessors)
+    end
+  end
+
+  context 'when preprocessor defined' do
+    let(:lenjador) { described_class.new([adapter], [preprocessor]) }
+    let(:adapter) { double }
+    let(:preprocessor) { double }
+    let(:data) { {data: 'data'} }
+
+    it 'preprocesses data before logging' do
+      expect(preprocessor).to receive(:process).with(data).and_return(data.merge(processed: true)).ordered
+      expect(adapter).to receive(:log).with(:info, data.merge(processed: true)).ordered
+
+      lenjador.info(data)
+    end
+  end
+
+  context 'when parsing log data' do
+    let(:lenjador) { described_class.new([adapter], preprocessors) }
+    let(:adapter) { double }
+    let(:preprocessors) { [] }
+
+    it 'parses empty string with nil metadata' do
+      expect(adapter).to receive(:log).with(:info, message: '')
+
+      lenjador.info('', nil)
+    end
+
+    it 'parses nil as metadata' do
+      expect(adapter).to receive(:log).with(:info, message: nil)
+
+      lenjador.info(nil)
+    end
+
+    it 'parses only message' do
+      expect(adapter).to receive(:log).with(:info, message: 'test message')
+
+      lenjador.info 'test message'
+    end
+
+    it 'parses only metadata' do
+      expect(adapter).to receive(:log).with(:info, test: 'data')
+
+      lenjador.info test: 'data'
+    end
+
+    it 'parses message and metadata' do
+      expect(adapter).to receive(:log).with(:info, message: 'test message', test: 'data')
+
+      lenjador.info 'test message', test: 'data'
+    end
+
+    it 'parses block as a message' do
+      message = 'test message'
+      expect(adapter).to receive(:log).with(:info, message: message)
+
+      lenjador.info { message }
+    end
+
+    it 'ignores progname on block syntax' do
+      message = 'test message'
+      expect(adapter).to receive(:log).with(:info, message: message)
+
+      lenjador.info('progname') { message }
+    end
+  end
+
+  context 'log level queries' do
+    context 'when adapter has debug level' do
+      let(:logger) do
+        described_class.build('test_service', stdout: {level: 'debug'})
+      end
+
+      it 'responds true to debug? and higher levels' do
+        expect(logger.debug?).to be(true)
+        expect(logger.info?).to be(true)
+        expect(logger.warn?).to be(true)
+        expect(logger.error?).to be(true)
+        expect(logger.fatal?).to be(true)
+      end
+    end
+
+    context 'when adapter has info level' do
+      let(:logger) do
+        described_class.build('test_service', stdout: {level: 'info'})
+      end
+
+      it 'responds true to info? and higher levels' do
+        expect(logger.debug?).to be(false)
+        expect(logger.info?).to be(true)
+        expect(logger.warn?).to be(true)
+        expect(logger.error?).to be(true)
+        expect(logger.fatal?).to be(true)
+      end
+    end
+  end
+
+  it 'has the same interface as Ruby logger' do
+    skip "https://salemove.atlassian.net/browse/INF-464"
+    logger = described_class.build('test_service', stdout: {level: 'debug'})
+    expect(logger).to implement_interface(Logger)
+  end
+end

data/spec/preprocessors/blacklist_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require_relative '../../lib/lenjador/preprocessors/blacklist'
+
+describe Lenjador::Preprocessors::Blacklist do
+  subject(:processed_data) { described_class.new(config).process(data) }
+
+  let(:config) {{
+    fields: [{ key: 'field', action: action }]
+  }}
+
+  let(:action) {}
+  let(:data) {{
+    field: value,
+    data: {
+      field: 'secret'
+    },
+    array: [{field: 'secret'}]
+  }}
+
+  let(:value) { 'secret' }
+
+  context 'when action is unsupported' do
+    let(:action) { 'reverse' }
+
+    it 'throws exception' do
+      expect { processed_data }.to raise_exception(Lenjador::Preprocessors::Blacklist::UnsupportedActionException)
+    end
+  end
+
+  context 'when action is "exclude"' do
+    let(:action) { 'exclude' }
+
+    it 'removes the field' do
+      expect(processed_data).not_to include(:field)
+    end
+
+    it 'removes nested field' do
+      expect(processed_data).not_to include_at_depth({field: 'secret'}, 1)
+    end
+
+    it 'removes nested in array field' do
+      expect(processed_data[:array]).not_to include({field: 'secret'})
+    end
+
+    context 'when field is deeply nested' do
+      let(:depth) { 10 }
+      let(:data) { data_with_nested_field({field: 'secret'}, depth) }
+
+      it 'removes deeply nested field' do
+        expect(processed_data).not_to include_at_depth({field: 'secret'}, depth)
+      end
+    end
+  end
+
+  context 'when action is "mask"' do
+    let(:action) { 'mask' }
+
+    it 'masks nested field' do
+      expect(processed_data).to include_at_depth({field: '*****'}, 1)
+    end
+
+    it 'masks nested in array field' do
+      expect(processed_data[:array]).to include({field: '*****'})
+    end
+
+    context 'when field is string' do
+      let(:value) { 'secret' }
+
+      it 'masks value with asterisks' do
+        expect(processed_data).to include(field: '*****')
+      end
+    end
+
+    context 'when field is number' do
+      let(:value) { 42 }
+
+      it 'masks number value' do
+        expect(processed_data).to include(field: '*****')
+      end
+    end
+
+    context 'when field is boolean' do
+      let(:value) { true }
+
+      it 'masks value with asterisks' do
+        expect(processed_data).to include(field: '*****')
+      end
+    end
+
+    context 'when field is array' do
+      let(:value) { [1,2,3,4] }
+
+      it 'masks value with asterisks' do
+        expect(processed_data).to include(field: '*****')
+      end
+    end
+
+    context 'when field is hash' do
+      let(:value) { {data: {}} }
+
+      it 'masks value with asterisks' do
+        expect(processed_data).to include(field: '*****')
+      end
+    end
+
+    context 'when field is deeply nested' do
+      let(:depth) { 10 }
+      let(:data) { data_with_nested_field({field: 'secret'}, depth) }
+
+      it 'masks deeply nested field' do
+        expect(processed_data).to include_at_depth({field: '*****'}, depth)
+      end
+    end
+  end
+
+  def data_with_nested_field(field, depth)
+    depth.times.inject(field) do |mem|
+      {}.merge(data: mem)
+    end
+  end
+
+  RSpec::Matchers.define :include_at_depth do |expected_hash, depth|
+    match do |actual|
+      nested_data = depth.times.inject(actual) do |mem|
+        mem[:data]
+      end
+
+      expect(nested_data).to include(expected_hash)
+    end
+  end
+end

data/spec/preprocessors/json_pointer_trie.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'lenjador/preprocessors/json_pointer_trie'
+
+RSpec.describe Lenjador::Preprocessors::JSONPointerTrie do
+  let(:trie) { described_class.new }
+
+  describe '#includes?' do
+    it 'returns true for empty prefix' do
+      expect(trie).to include('')
+    end
+
+    it 'returns true if trie contains requested prefix or value itself' do
+      trie.insert('/data/nested/key')
+
+      expect(trie).to include('/data')
+      expect(trie).to include('/data/nested')
+      expect(trie).to include('/data/nested/key')
+    end
+
+    it 'returns false if trie does not contain requested prefix or value' do
+      trie.insert('/data/nested/key')
+
+      expect(trie).to_not include('/bad_data')
+      expect(trie).to_not include('/data/bad_nested')
+      expect(trie).to_not include('/data/nested/bad_key')
+    end
+
+    it 'returns true if trie contains requested prefix under wildcard' do
+      trie.insert('/data/~/key')
+
+      expect(trie).to include('/data/arbitrary_key/key')
+      expect(trie).to include('/data/another_key/key')
+      expect(trie).to_not include('/data/arbitrary_key/bad_nested_key')
+    end
+  end
+end