logasm-jruby 1.2.0

data/lib/logasm/preprocessors/json_pointer_trie.rb

@@ -0,0 +1,40 @@
+require 'lru_redux'
+
+class Logasm
+  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/logasm/preprocessors/strategies/mask.rb

@@ -0,0 +1,43 @@
+class Logasm
+  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/logasm/preprocessors/strategies/prune.rb

@@ -0,0 +1,44 @@
+class Logasm
+  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/logasm/preprocessors/whitelist.rb

@@ -0,0 +1,56 @@
+require 'logasm/preprocessors/json_pointer_trie'
+require 'logasm/preprocessors/strategies/mask'
+require 'logasm/preprocessors/strategies/prune'
+
+class Logasm
+  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/logasm/utils.rb

@@ -0,0 +1,91 @@
+require 'time'
+
+class Logasm
+  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/logasm.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 = 'logasm-jruby'
+  else
+    gem.name = 'logasm'
+  end
+
+  gem.version       = '1.2.0'
+  gem.authors       = ["Salemove"]
+  gem.email         = ["support@salemove.com"]
+  gem.description   = %q{It's logasmic}
+  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/spec/adapters/stdout_adapter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require_relative '../../lib/logasm/adapters/stdout_adapter'
+
+describe Logasm::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,43 @@
+require 'spec_helper'
+require 'json'
+require_relative '../../lib/logasm/adapters/stdout_json_adapter'
+
+describe Logasm::Adapters::StdoutJsonAdapter do
+  let(:debug_level_code) { 0 }
+  let(:debug_level) { Logasm::Adapters::LOG_LEVELS[debug_level_code] }
+  let(:info_level_code) { 1 }
+  let(:info_level) { Logasm::Adapters::LOG_LEVELS[info_level_code] }
+
+  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(Logasm::Utils).to receive(:build_event)
+          .with(metadata, info_level, application_name)
+          .and_return(event)
+      end
+
+      it 'sends serialized event to STDOUT' do
+        expect(STDOUT).to receive(:puts).with(serialized_event)
+        adapter.log(info_level, metadata)
+      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
+        expect(STDOUT).to_not receive(:puts)
+        adapter.log(debug_level, metadata)
+      end
+    end
+  end
+end

data/spec/logasm_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Logasm 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(:logasm) { 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
+
+      logasm.info(data)
+    end
+  end
+
+  context 'when parsing log data' do
+    let(:logasm) { 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: '')
+
+      logasm.info('', nil)
+    end
+
+    it 'parses nil as metadata' do
+      expect(adapter).to receive(:log).with(:info, message: nil)
+
+      logasm.info(nil)
+    end
+
+    it 'parses only message' do
+      expect(adapter).to receive(:log).with(:info, message: 'test message')
+
+      logasm.info 'test message'
+    end
+
+    it 'parses only metadata' do
+      expect(adapter).to receive(:log).with(:info, test: 'data')
+
+      logasm.info test: 'data'
+    end
+
+    it 'parses message and metadata' do
+      expect(adapter).to receive(:log).with(:info, message: 'test message', test: 'data')
+
+      logasm.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)
+
+      logasm.info { message }
+    end
+
+    it 'ignores progname on block syntax' do
+      message = 'test message'
+      expect(adapter).to receive(:log).with(:info, message: message)
+
+      logasm.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