semlogr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44319632b673642da11033922b58b637648dec0d
+  data.tar.gz: 8a126de2e979a82ea257ded4e2f1656aed3ee6c8
+SHA512:
+  metadata.gz: 57772d694203303b49127e2fb37761828a34c8b7562cc1637b00fd9c7daa7e0ee15842c88a697cb088d04a6d9cdb5630c26c1cd379a1fbac2009db218049aafc
+  data.tar.gz: 699347ab3818596b392c6cfa1a4fc4849cefc48580bd1e54424a8c6f2046ef4ad6661fc969bd4e017804ef7bfbd6ce5de618d4af449539a9638c7b65150efa42

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.tags*

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,17 @@
+AllCops:
+  TargetRubyVersion: 2.2
+
+Documentation:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 24
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/LineLength:
+  Max: 120
+Metrics/MethodLength:
+  Max: 20
+
+Style/MultilineMethodCallIndentation:
+  EnforcedStyle: indented

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Semlogr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+![Codeship Status for semlogr/semlogr](https://codeship.com/projects/b5709d40-3693-0134-2dce-36dc468776c7/status?branch=master)
+
+# Semlogr
+
+Semlogr is a semantic logger for Ruby inspired by the amazing semantic logger for .NET [Serilog](http://serilog.net/).
+
+## Installation
+
+To install:
+
+    gem install semlogr
+
+Or if using bundler, add semlogr to your Gemfile:
+
+    gem 'semlogr'
+
+then:
+
+    bundle install
+
+## Getting Started
+
+Create an instance of the logger configuring one or more sinks.
+
+```ruby
+require "semlogr"
+require "semlogr/sinks/colored_console"
+
+logger = Semlogr::Logger.create do |c|
+  c.log_at(Semlogr::LogSeverity::INFO)
+
+  c.write_to(Semlogr::Sinks::ColoredConsole.new)
+end
+
+logger.info('Customer {customer_id} did something interesting', customer_id: 1234)
+```
+
+## Development
+
+After cloning the repository run `bundle install` to get up and running, to run the specs just run `rake spec`. You can also experiment in an interactive pry console using `bin/console`.
+
+## Changes
+
+### 0.1.0
+
+  - Initial commit, long long way to go :)!
+
+## Contributing
+
+See anything broken or something you would like to improve? feel free to submit an issue or better yet a pull request!

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'semlogr'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/semlogr/enrichers/host.rb

@@ -0,0 +1,11 @@
+require 'socket'
+
+module Semlogr
+  module Enrichers
+    class Host
+      def enrich(log_event)
+        log_event.add_property(host: Socket.gethostname)
+      end
+    end
+  end
+end

data/lib/semlogr/enrichers/property.rb

@@ -0,0 +1,13 @@
+module Semlogr
+  module Enrichers
+    class Property
+      def initialize(**properties)
+        @properties = properties
+      end
+
+      def enrich(log_event)
+        log_event.add_property(@properties)
+      end
+    end
+  end
+end

data/lib/semlogr/enrichers/thread.rb

@@ -0,0 +1,9 @@
+module Semlogr
+  module Enrichers
+    class Thread
+      def enrich(log_event)
+        log_event.add_property(thread_id: ::Thread.current.object_id)
+      end
+    end
+  end
+end

data/lib/semlogr/events/log_event.rb

@@ -0,0 +1,39 @@
+module Semlogr
+  module Events
+    class LogEvent
+      attr_reader :severity
+      attr_reader :template
+      attr_reader :error
+      attr_reader :properties
+      attr_reader :timestamp
+
+      def initialize(severity, template, error, properties)
+        @timestamp = Time.now.utc
+        @severity = severity
+        @template = template
+        @error = error
+        @properties = properties
+      end
+
+      def get_property(name)
+        @properties[name]
+      end
+
+      def add_property(properties)
+        @properties.merge!(properties)
+      end
+
+      def render(output)
+        @template.render(output, @properties)
+      end
+
+      def to_s
+        output = ''
+
+        render(output)
+
+        output
+      end
+    end
+  end
+end

data/lib/semlogr/formatters/json_formatter.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Semlogr
+  module Formatters
+    class JsonFormatter
+      def format(log_event)
+        event = {
+          timestamp: log_event.timestamp.iso8601(3),
+          severity: log_event.severity,
+          message: log_event.to_s
+        }
+
+        add_error(event, log_event.error)
+        add_properties(event, log_event.properties)
+
+        yield(event) if block_given?
+
+        "#{event.to_json}\n"
+      end
+
+      private
+
+      def add_error(event, error)
+        return unless error
+
+        backtrace = error.backtrace || []
+        event[:error] = {
+          type: error.class,
+          message: error.message,
+          backtrace: backtrace.join("\n")
+        }
+      end
+
+      def add_properties(event, properties)
+        return unless properties.any?
+
+        event[:properties] = properties
+      end
+    end
+  end
+end

data/lib/semlogr/formatters/property_value_formatter.rb

@@ -0,0 +1,28 @@
+module Semlogr
+  module Formatters
+    class PropertyValueFormatter
+      QUOTE = '"'.freeze
+
+      def self.format(output, property_value)
+        case property_value
+        when nil
+          output << '(nil)'.freeze
+        when String
+          output << QUOTE
+          output << property_value
+          output << QUOTE
+        when StandardError
+          output << "#{property_value.class}: #{property_value.message}"
+
+          if property_value.backtrace
+            output << "\n\s\s#{property_value.backtrace.join("\n\s\s")}"
+          end
+
+          output << "\n"
+        else
+          output << property_value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/semlogr/formatters/text_formatter.rb

@@ -0,0 +1,35 @@
+require 'semlogr/templates/parser'
+require 'semlogr/properties/output_properties'
+require 'semlogr/templates/property_token'
+
+module Semlogr
+  module Formatters
+    class TextFormatter
+      DEFAULT_TEMPLATE = "[{timestamp}] {severity}: {message}\n{error}".freeze
+
+      def initialize(template: DEFAULT_TEMPLATE)
+        @template = Templates::Parser.parse(template)
+      end
+
+      def format(log_event)
+        output = ''
+        output_properties = Properties::OutputProperties.create(log_event)
+
+        @template.tokens.each do |token|
+          case token
+          when Templates::PropertyToken
+            if token.property_name == :message
+              log_event.render(output)
+            elsif output_properties[token.property_name]
+              token.render(output, output_properties)
+            end
+          else
+            token.render(output, output_properties)
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/semlogr/log_severity.rb

@@ -0,0 +1,26 @@
+module Semlogr
+  class LogSeverity
+    include Comparable
+
+    attr_reader :value
+
+    def initialize(value, display_string)
+      @value = value
+      @display_string = display_string
+    end
+
+    def <=>(other)
+      @value <=> other.value
+    end
+
+    def to_s
+      @display_string
+    end
+
+    DEBUG = LogSeverity.new(::Logger::DEBUG, 'DEBUG')
+    INFO = LogSeverity.new(::Logger::INFO, 'INFO')
+    WARN = LogSeverity.new(::Logger::WARN, 'WARN')
+    ERROR = LogSeverity.new(::Logger::ERROR, 'ERROR')
+    FATAL = LogSeverity.new(::Logger::FATAL, 'FATAL')
+  end
+end

data/lib/semlogr/logger.rb

@@ -0,0 +1,109 @@
+require 'logger'
+require 'semlogr/logger_configuration'
+require 'semlogr/log_severity'
+require 'semlogr/events/log_event'
+require 'semlogr/templates/parser'
+require 'semlogr/enrichers/property'
+
+module Semlogr
+  class Logger
+    def initialize(min_severity, enrichers, filters, sinks)
+      @min_severity = min_severity
+      @filters = filters
+      @enrichers = enrichers
+      @sinks = sinks
+    end
+
+    def self.create
+      config = LoggerConfiguration.new
+      yield(config)
+
+      config.create_logger
+    end
+
+    def debug?
+      @min_severity <= LogSeverity::DEBUG
+    end
+
+    def info?
+      @min_severity <= LogSeverity::INFO
+    end
+
+    def warn?
+      @min_severity <= LogSeverity::WARN
+    end
+
+    def error?
+      @min_severity <= LogSeverity::ERROR
+    end
+
+    def fatal?
+      @min_severity <= LogSeverity::FATAL
+    end
+
+    def debug(template = nil, error: nil, **properties, &block)
+      log(LogSeverity::DEBUG, template, error, properties, &block)
+    end
+
+    def info(template = nil, error: nil, **properties, &block)
+      log(LogSeverity::INFO, template, error, properties, &block)
+    end
+
+    def warn(template = nil, error: nil, **properties, &block)
+      log(LogSeverity::WARN, template, error, properties, &block)
+    end
+
+    def error(template = nil, error: nil, **properties, &block)
+      log(LogSeverity::ERROR, template, error, properties, &block)
+    end
+
+    def fatal(template = nil, error: nil, **properties, &block)
+      log(LogSeverity::FATAL, template, error, properties, &block)
+    end
+
+    def with_context(**properties)
+      Logger.new(
+        @min_severity,
+        @enrichers + [Enrichers::Property.new(properties)],
+        @filters,
+        @sinks
+      )
+    end
+
+    private
+
+    def log(severity, template, error, properties, &block)
+      return true if @sinks.size.zero?
+      return true if severity < @min_severity
+
+      if template.nil? && block
+        template, properties = yield
+
+        properties ||= {}
+        error = properties[:error]
+      end
+
+      log_event = create_log_event(severity, template, error, properties)
+
+      @filters.each do |filter|
+        return false if filter.call(log_event)
+      end
+
+      @enrichers.each do |enricher|
+        enricher.enrich(log_event)
+      end
+
+      @sinks.each do |sink|
+        sink.emit(log_event)
+      end
+
+      true
+    end
+
+    def create_log_event(severity, template, error, properties)
+      template = Templates::Parser.parse(template)
+
+      Events::LogEvent.new(severity, template, error, properties)
+    end
+  end
+end

data/lib/semlogr/logger_configuration.rb

@@ -0,0 +1,40 @@
+module Semlogr
+  class LoggerConfiguration
+    attr_reader :min_severity
+    attr_reader :enrichers
+    attr_reader :filters
+    attr_reader :sinks
+
+    def initialize
+      @min_severity = LogSeverity::DEBUG
+      @enrichers = []
+      @filters = []
+      @sinks = []
+    end
+
+    def log_at(severity)
+      @min_severity = severity
+    end
+
+    def filter_when(filter)
+      @filters << filter
+    end
+
+    def enrich_with(enricher)
+      @enrichers << enricher
+    end
+
+    def write_to(sink)
+      @sinks << sink
+    end
+
+    def create_logger
+      Logger.new(
+        @min_severity,
+        @enrichers,
+        @filters,
+        @sinks
+      )
+    end
+  end
+end

data/lib/semlogr/properties/output_properties.rb

@@ -0,0 +1,16 @@
+module Semlogr
+  module Properties
+    class OutputProperties
+      def self.create(log_event)
+        properties = log_event.properties.merge(
+          timestamp: log_event.timestamp,
+          severity: log_event.severity
+        )
+
+        properties[:error] = log_event.error if log_event.error
+
+        properties
+      end
+    end
+  end
+end

data/lib/semlogr/sinks/colored_console.rb

@@ -0,0 +1,88 @@
+require 'semlogr/sinks/console'
+require 'semlogr/properties/output_properties'
+
+module Semlogr
+  module Sinks
+    class ColoredConsole
+      DEFAULT_TEMPLATE = "[{timestamp}] {severity}: {message}\n{error}".freeze
+
+      LOG_SEVERITY_COLORS = {
+        LogSeverity::DEBUG => :white,
+        LogSeverity::INFO => :white,
+        LogSeverity::WARN => :yellow,
+        LogSeverity::ERROR => :red,
+        LogSeverity::FATAL => :red
+      }.freeze
+
+      COLOR_CODES = {
+        white: 37,
+        yellow: 33,
+        red: 31,
+        blue: 34
+      }.freeze
+
+      def initialize(template: DEFAULT_TEMPLATE)
+        @template = Templates::Parser.parse(template)
+      end
+
+      def emit(log_event)
+        output = ''
+        output_properties = Properties::OutputProperties.create(log_event)
+
+        @template.tokens.each do |token|
+          case token
+          when Templates::PropertyToken
+            render_property_token(output, token, log_event, output_properties)
+          else
+            token.render(output, output_properties)
+          end
+        end
+
+        STDOUT.write(output)
+      end
+
+      private
+
+      def render_property_token(output, token, log_event, output_properties)
+        case token.property_name
+        when :message
+          render_message(output, log_event)
+        when :severity
+          color = LOG_SEVERITY_COLORS[log_event.severity] || :white
+          colorize(output, color) do
+            token.render(output, output_properties)
+          end
+        when :error
+          return unless output_properties[:error]
+
+          colorize(output, :red) do
+            token.render(output, output_properties)
+          end
+        else
+          return unless output_properties[token.property_name]
+
+          token.render(output, output_properties)
+        end
+      end
+
+      def render_message(output, log_event)
+        log_event.template.tokens.each do |token|
+          case token
+          when Templates::PropertyToken
+            colorize(output, :blue) do
+              token.render(output, log_event.properties)
+            end
+          else
+            token.render(output, log_event.properties)
+          end
+        end
+      end
+
+      def colorize(output, color)
+        output << "\e[#{COLOR_CODES[color]}m"
+        yield
+        output << "\e[0m"
+      end
+    end
+  end
+end

data/lib/semlogr/sinks/console.rb

@@ -0,0 +1,16 @@
+require 'semlogr/formatters/text_formatter'
+
+module Semlogr
+  module Sinks
+    class Console
+      def initialize(formatter: nil)
+        @formatter = formatter || Formatters::TextFormatter.new
+      end
+
+      def emit(log_event)
+        output = @formatter.format(log_event)
+        STDOUT.write(output)
+      end
+    end
+  end
+end

data/lib/semlogr/sinks/file.rb

@@ -0,0 +1,17 @@
+require 'semlogr/formatters/text_formatter'
+
+module Semlogr
+  module Sinks
+    class File
+      def initialize(file, shift_age: nil, shift_size: nil, formatter: nil)
+        @logdev = ::Logger::LogDevice.new(file, shift_age: shift_age, shift_size: shift_size)
+        @formatter = formatter || Formatters::TextFormatter.new
+      end
+
+      def emit(log_event)
+        output = @formatter.format(log_event)
+        @logdev.write(output)
+      end
+    end
+  end
+end

data/lib/semlogr/templates/parser.rb

@@ -0,0 +1,79 @@
+require 'semlogr/templates/template'
+require 'semlogr/templates/text_token'
+require 'semlogr/templates/property_token'
+require 'semlogr/templates/template_cache'
+
+module Semlogr
+  module Templates
+    class Parser
+      @template_cache = TemplateCache.new(1000)
+
+      PROPERTY_TOKEN_START = '{'.freeze
+      PROPERTY_TOKEN_END = '}'.freeze
+
+      def self.parse(template)
+        return Template::EMPTY unless template && !template.empty?
+
+        cached_template = @template_cache[template]
+        return cached_template if cached_template
+
+        tokens = []
+        pos = 0
+
+        while pos < template.size
+          text_token, pos = parse_text_token(template, pos)
+          tokens.push(text_token) if text_token
+
+          property_token, pos = parse_property_token(template, pos)
+          tokens.push(property_token) if property_token
+        end
+
+        @template_cache[template] = Template.new(tokens)
+      end
+
+      def self.parse_text_token(template, start)
+        token = nil
+        pos = start
+
+        while pos < template.size
+          break if template[pos] == PROPERTY_TOKEN_START
+
+          pos += 1
+        end
+
+        if pos > start
+          text = template[start..pos - 1]
+          token = TextToken.new(text)
+        end
+
+        [token, pos]
+      end
+
+      def self.parse_property_token(template, start)
+        return [nil, start] unless template[start] == PROPERTY_TOKEN_START
+
+        token = nil
+        pos = start
+
+        while pos < template.size
+          if template[pos] == PROPERTY_TOKEN_END
+            raw_text = template[start..pos]
+            property_name = raw_text[1..-2]
+            token = PropertyToken.new(raw_text, property_name.to_sym)
+
+            return [token, pos + 1]
+          end
+
+          pos += 1
+        end
+
+        if pos > start
+          text = template[start..pos - 1]
+          token = TextToken.new(text)
+        end
+
+        [token, pos]
+      end
+    end
+  end
+end

data/lib/semlogr/templates/property_token.rb

@@ -0,0 +1,39 @@
+require 'semlogr/formatters/property_value_formatter'
+
+module Semlogr
+  module Templates
+    class PropertyToken
+      attr_accessor :property_name
+
+      def initialize(raw_text, property_name)
+        @raw_text = raw_text
+        @property_name = property_name
+      end
+
+      def render(output, properties)
+        if properties.key?(@property_name)
+          property_value = properties[@property_name]
+
+          Formatters::PropertyValueFormatter.format(output, property_value)
+        else
+          output << @raw_text
+        end
+      end
+
+      def ==(other)
+        return false unless other
+        return false unless other.respond_to?(:property_name)
+
+        @property_name == other.property_name
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        @property_name.hash
+      end
+    end
+  end
+end

data/lib/semlogr/templates/template.rb

@@ -0,0 +1,21 @@
+require 'semlogr/templates/text_token'
+
+module Semlogr
+  module Templates
+    class Template
+      attr_accessor :tokens
+
+      def initialize(tokens)
+        @tokens = tokens
+      end
+
+      def render(output, properties)
+        @tokens.each do |token|
+          token.render(output, properties)
+        end
+      end
+
+      EMPTY = Template.new([TextToken::EMPTY])
+    end
+  end
+end

data/lib/semlogr/templates/template_cache.rb

@@ -0,0 +1,19 @@
+require 'lru_redux'
+
+module Semlogr
+  module Templates
+    class TemplateCache
+      def initialize(max_size)
+        @template_cache = LruRedux::ThreadSafeCache.new(max_size)
+      end
+
+      def [](key)
+        @template_cache[key]
+      end
+
+      def []=(key, value)
+        @template_cache[key] = value
+      end
+    end
+  end
+end

data/lib/semlogr/templates/text_token.rb

@@ -0,0 +1,32 @@
+module Semlogr
+  module Templates
+    class TextToken
+      attr_accessor :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def render(output, _properties)
+        output << @text
+      end
+
+      def ==(other)
+        return false unless other
+        return false unless other.respond_to?(:text)
+
+        @text == other.text
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        @text.hash
+      end
+
+      EMPTY = TextToken.new('')
+    end
+  end
+end

data/lib/semlogr/version.rb

@@ -0,0 +1,3 @@
+module Semlogr
+  VERSION = '0.1.0'.freeze
+end

data/lib/semlogr.rb

@@ -0,0 +1,39 @@
+require 'semlogr/logger'
+
+module Semlogr
+  @logger = nil
+
+  def self.configure
+    @logger = Logger.create do |config|
+      yield(config)
+    end
+  end
+
+  def self.logger
+    unless @logger
+      raise StandardError, 'You need to initialize the logger instance by calling Semlogr::Log.configure first!'
+    end
+
+    @logger
+  end
+
+  def self.debug(template = nil, **properties, &block)
+    logger.debug(template, **properties, &block)
+  end
+
+  def self.info(template = nil, **properties, &block)
+    logger.info(template, **properties, &block)
+  end
+
+  def self.warn(template = nil, **properties, &block)
+    logger.warn(template, **properties, &block)
+  end
+
+  def self.error(template = nil, **properties, &block)
+    logger.error(template, **properties, &block)
+  end
+
+  def self.fatal(template = nil, **properties, &block)
+    logger.fatal(template, **properties, &block)
+  end
+end

data/samples/basic.rb

@@ -0,0 +1,64 @@
+require 'bundler/setup'
+require 'semlogr'
+require 'semlogr/sinks/console'
+require 'semlogr/sinks/colored_console'
+require 'semlogr/sinks/file'
+require 'semlogr/formatters/json_formatter'
+require 'semlogr/enrichers/thread'
+require 'semlogr/enrichers/host'
+require 'semlogr/enrichers/property'
+
+logger = Semlogr::Logger.create do |c|
+  c.log_at Semlogr::LogSeverity::DEBUG
+
+  c.write_to Semlogr::Sinks::Console.new
+  c.write_to Semlogr::Sinks::ColoredConsole.new
+  c.write_to Semlogr::Sinks::Console.new(formatter: Semlogr::Formatters::JsonFormatter.new)
+
+  c.enrich_with Semlogr::Enrichers::Thread.new
+  c.enrich_with Semlogr::Enrichers::Host.new
+  c.enrich_with Semlogr::Enrichers::Property.new(version: '1.0')
+
+  c.filter_when lambda { |log_event|
+    log_event.get_property(:id) == 123
+  }
+end
+
+logger.debug('Test {id}, string {string}')
+logger.debug('Test {id}, string {string}', id: nil, string: nil)
+logger.debug('Test {id}, string {string}', id: 123, string: 'foo')
+logger.debug('Test {id}, string {string}', id: 1234, string: 'foo')
+logger.info('Test {id}, string {string}', id: 1234, string: 'foo')
+logger.warn('Test {id}, string {string}', id: 1234, string: 'foo')
+logger.fatal('Test {id}, string {string}', id: 1234, string: 'foo')
+logger.fatal('Test array {array}', array: [1, 2, 3, 'foo'])
+
+logger.debug do
+  'Testing with a block'
+end
+
+logger.debug do
+  ['Testing with a block, id: {id}', id: 1234]
+end
+
+logger.error('ERROR!!!', error: StandardError.new('test'))
+logger.error('ERROR!!!', error: StandardError.new('test'))
+
+begin
+  def bob
+    foo
+  end
+
+  def foo
+    raise StandardError, 'foo'
+  end
+
+  bob
+rescue => ex
+  logger.warn('Oops, id: {id}', id: 1234, error: ex)
+  logger.error('Oops, id: {id}', id: 1234, error: ex)
+
+  logger.error do
+    ['Testing error with a block, id: {id}', error: ex, id: 1234]
+  end
+end

data/semlogr.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'semlogr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'semlogr'
+  spec.version       = Semlogr::VERSION
+  spec.authors       = ['Stefan Sedich']
+  spec.email         = ['stefan.sedich@gmail.com']
+
+  spec.summary       = 'Semantic logging for Ruby'
+  spec.description   = 'A modern semantic logger for Ruby inspired by Serilog.'
+  spec.homepage      = 'https://github.com/semlogr/semlogr'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'lru_redux', '~> 1.1.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'pry', '~> 0.10.3'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.43'
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: semlogr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stefan Sedich
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.43'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.43'
+description: A modern semantic logger for Ruby inspired by Serilog.
+email:
+- stefan.sedich@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/semlogr.rb
+- lib/semlogr/enrichers/host.rb
+- lib/semlogr/enrichers/property.rb
+- lib/semlogr/enrichers/thread.rb
+- lib/semlogr/events/log_event.rb
+- lib/semlogr/formatters/json_formatter.rb
+- lib/semlogr/formatters/property_value_formatter.rb
+- lib/semlogr/formatters/text_formatter.rb
+- lib/semlogr/log_severity.rb
+- lib/semlogr/logger.rb
+- lib/semlogr/logger_configuration.rb
+- lib/semlogr/properties/output_properties.rb
+- lib/semlogr/sinks/colored_console.rb
+- lib/semlogr/sinks/console.rb
+- lib/semlogr/sinks/file.rb
+- lib/semlogr/templates/parser.rb
+- lib/semlogr/templates/property_token.rb
+- lib/semlogr/templates/template.rb
+- lib/semlogr/templates/template_cache.rb
+- lib/semlogr/templates/text_token.rb
+- lib/semlogr/version.rb
+- output.html
+- samples/basic.rb
+- semlogr.gemspec
+homepage: https://github.com/semlogr/semlogr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Semantic logging for Ruby
+test_files: []