u-log 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b29ab5eaabe74647d865740ccd810a406a31e103
+  data.tar.gz: 2ebf738981d7231f0035b34fc0354694eb04069e
+SHA512:
+  metadata.gz: fdf58a1d3f8161dcbd6354d39eeff60ea1e59c2cc2f47b3861e2b84e1084fc8b486cf5049ebc1632fee8f343babe14edf5f47031483b6c57d31b4bf20a694227
+  data.tar.gz: f940536cc3aa21e48940ee588827189e1741df56ab4479479f990a88ea357fb8e93a79a8d9837694f2defb49c12c4290fec2ae27cd1346600392dd83213989c2

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    u-log (0.0.1)
+      lines
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark-ips (1.2.0)
+    lines (0.2.0)
+    minitest (5.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  benchmark-ips
+  minitest
+  u-log!

data/README.md

@@ -0,0 +1,100 @@
+U::Log - a different take on logging
+====================================
+
+[![Build
+Status](https://travis-ci.org/zimbatm/u-log.svg?branch=master)](https://travis-ci.org/zimbatm/u-log)
+
+An oppinionated logging library.
+
+* Log everything in development AND production.
+* Logs should be easy to read, grep and parse.
+* Logging something should never fail.
+* Let the system handle the storage. Write to syslog or STDERR.
+* No log levels necessary. Just log whatever you want.
+
+STATUS: ALPHA
+=============
+
+Doc is still scarce so it's quite hard to get started. I think reading the
+lib/u-log.rb should give a good idea of the capabilities.
+
+It would be nice to expose a method that resolves a context into a hash. It's
+useful to share the context with other tools like an error reporter. Btw,
+Sentry/Raven is great.
+
+Quick intro
+-----------
+
+```ruby
+require 'u-log'
+
+# Setups the outputs. IO and Syslog are supported.
+l = U::Log.new($stderr, Lines,
+  at:  ->{ Time.now.utc },
+  pid: ->{ Process.pid },
+)
+
+# First example
+l.log(foo: 'bar') # logs: at=2013-07-14T14:19:28Z foo=bar
+
+# If not a hash, the argument is transformed. A second argument is accepted as
+# a hash
+l.log("Hey", count: 3) # logs: at=2013-07-14T14:19:28Z msg=Hey count=3
+
+# You can also keep a context
+class MyClass < ActiveRecord::Base
+  attr_reader :lines
+  def initialize(logger)
+    @logger = logger.context(my_class_id: self.id)
+  end
+
+  def do_something
+    logger.log("Something happened")
+    # logs: at=2013-07-14T14:19:28Z msg='Something happeend' my_class_id: 2324
+  end
+end
+```
+
+Features
+--------
+
+* Simple to use
+* Thread safe (if the IO#write is)
+* Designed to not raise exceptions (unless it's an IO issue)
+* A backward-compatible Logger is provided in case you want to retrofit
+* require "u-log/active_record" for sane ActiveRecord logs
+* "u-log/rack_logger" is a logging middleware for Rack
+
+Known issues
+------------
+
+Syslog seems to truncate lines longer than 2056 chars and Lines makes if very
+easy to put too much data.
+
+Lines logging speed is reasonable but it could be faster. It writes at around
+5000 lines per second to Syslog on my machine.
+
+Inspired by
+-----------
+
+ * Scrolls : https://github.com/asenchi/scrolls
+ * Lograge : https://github.com/roidrage/lograge
+
+
+
+
+
+* Very simple (aka. fast)
+* No log level
+
+
+
+TODO
+----
+
+Error reporting
+
+Create message context
+
+
+Because the log context is hierarchical, 

data/bench_concat.rb

@@ -0,0 +1,26 @@
+require 'benchmark/ips'
+require 'stringio'
+
+data = 100.times.map{ 'sadfljkasfjlk' }
+
+Benchmark.ips do |x|
+  x.report "join" do |n|
+    n.times do
+      data.join
+    end
+  end
+  x.report "StringIO" do |n|
+    n.times do
+      s = StringIO.new('wb')
+      data.each do |y|
+        s.write y
+      end
+      s.string
+    end
+  end
+  x.report "inject+" do |n|
+    n.times do
+      data.inject(&:+)
+    end
+  end
+end

data/lib/u-log.rb

@@ -0,0 +1,113 @@
+# U::Log is an opinionated logging library.
+#
+# The main take is that logs are structured.
+# Too much time is spend formatting logs, they should look nice by default.
+# That's why U::Log uses the lines format by default.
+#
+# Log everything in development AND production.
+# Logs should be easy to read, grep and parse.
+# Logging something should never fail.
+# Let the system handle the storage. Write to syslog or STDERR.
+# No log levels necessary. Just log whatever you want.
+#
+# Example:
+#
+#     U.log("Oops !", foo: {}, g: [])
+#     #outputs:
+#     # at=2013-03-07T09:21:39Z pid=3242 app=some-process msg="Oops !" foo={} g=[]
+#
+# Usage:
+#
+#     
+#     U.log(foo: 3, msg: "This")
+#
+#     ctx = U.log_context(encoding_id: Log.id)
+#     ctx.log({})
+#
+module U; module Log
+  # A very simple logger and log context
+  #
+  class Logger
+    NL = "\n".freeze
+
+    # +out+ is the log destination. Has a #<< method that takes a string.
+    # +format+ is what transforms the data into a string using the #dump method
+    # +data+ is context data for the logger. Responds to #to_h.
+    def initialize(out, format, data)
+      @out = out
+      @format = format
+      @data = data.to_h
+    end
+
+    # Outputs the given arguments merged with the context.
+    def log(*args)
+      @out << with_data(args_to_hash args).to_s + NL
+    end
+
+    # Creates a derivative context so that `context(a: 1).context(b: 2)`
+    # is equivalent to `contect(a: 1, b: 2)`
+    def context(data = {})
+      return self unless data.to_h.any?
+      with_data @data.merge(data.to_h)
+    end
+
+    alias merge context
+
+    def to_s
+      @format.dump(evaluate_procs @data)
+    end
+
+    def to_h; @data; end
+
+    # Returns a ::Logger-compatible object.
+    #
+    # Make sure to require 'u-log/compat' before invoking this method.
+    #
+    def compat; Compat.new(self) end
+
+    protected
+
+    def with_data(data)
+      self.class.new @out, @format, data
+    end
+
+    def evaluate_procs(obj)
+      obj.each_with_object({}) do |(k,v), merged|
+        merged[k] = v.respond_to?(:call) ? (v.call rescue $!) : v
+      end
+    end
+
+    def args_to_hash(args)
+      return {} if args.empty?
+      data = @data.dup
+      # Allow the first argument to be a message
+      if !args.first.respond_to? :to_h
+        data.merge!(msg: args.shift)
+      end
+      args.inject(data) do |h, obj|
+        h.merge! obj.to_h
+      end
+      data
+    end
+  end
+end end
+
+require 'lines'
+
+module U
+  class << self
+    # Default logger that outputs to stderr with the Logfmt format
+    attr_accessor :logger
+
+    # shortcut for U.logger.log
+    def log(*args); logger.log(*args); end
+    # shotcut for U.logger.context
+    def log_context(data={}); logger.context(data); end
+  end
+
+  # Default global
+  self.logger = Log::Logger.new($stderr, Lines,
+    at:  ->{ Time.now.utc },
+    pid: ->{ Process.pid },
+  )
+end

data/lib/u-log/active_record.rb

@@ -0,0 +1,68 @@
+require 'active_record'
+require 'active_record/log_subscriber'
+require 'u-log'
+require 'u-log/compat'
+
+module U; module Log
+  class ActiveRecordSubscriber < ActiveSupport::LogSubscriber
+    def render_bind(column, value)
+      if column
+        if column.binary?
+          value = "<#{value.bytesize} bytes of binary data>"
+        end
+
+        [column.name, value]
+      else
+        [nil, value]
+      end
+    end
+
+    def sql(event)
+      payload = event.payload
+
+      return if payload[:name] == 'SCHEMA' || payload[:name] == 'EXPLAIN'
+
+      args = {}
+
+      args[:name] = payload[:name] if payload[:name]
+      args[:sql] = payload[:sql].squeeze(' ')
+
+      if payload[:binds] && payload[:binds].any?
+        args[:binds] = payload[:binds].inject({}) do |hash,(col, v)|
+          k, v = render_bind(col, v)
+          hash[k] = v
+          hash
+        end
+      end
+
+      args[:elapsed] = [event.duration.round(1), 'ms']
+
+      logger.ulogger.log(args)
+    end
+
+    def identity(event)
+      logger.ulogger.log(name: event.payload[:name], line: event.payload[:line])
+    end
+  end
+end end
+
+# Replace the base logger with our own compatible logger
+ActiveRecord::Base.logger = U.logger.compat
+
+# Subscribe u-log to the AR events
+U::Log::ActiveRecordSubscriber.attach_to :active_record
+
+# Remove the default ActiveRecord::LogSubscriber to avoid double outputs
+ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+  if subscriber.is_a?(ActiveRecord::LogSubscriber)
+    component = :active_record
+    events = subscriber.public_methods(false).reject{ |method| method.to_s == 'call' }
+    events.each do |event|
+      ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+        if listener.instance_variable_get('@delegate') == subscriber
+          ActiveSupport::Notifications.unsubscribe listener
+        end
+      end
+    end
+  end
+end

data/lib/u-log/compat.rb

@@ -0,0 +1,61 @@
+module U; module Log
+  # Backward-compatible with the stdlib Logger
+  # http://ruby-doc.org/stdlib-2.0/libdoc/logger/rdoc/Logger.html
+  class Compat
+    LEVELS = {
+      0 => :debug,
+      1 => :info,
+      2 => :warn,
+      3 => :error,
+      4 => :fatal,
+      5 => :unknown,
+    }
+
+    attr_reader :ulogger
+
+    def initialize(ulogger)
+      @ulogger = ulogger
+    end
+
+    def log(severity, message = nil, progname = nil, &block)
+      pri = LEVELS[severity] || severity
+      if block_given?
+        progname = message
+        message = yield rescue $!
+      end
+
+      data = { pri: pri }
+      data[:app] = progname if progname
+      data[:msg] = message if message
+
+      @logger.log(data)
+    end
+
+    LEVELS.values.each do |level|
+      eval "def #{level}(msg=nil, &block); log(:#{level}, msg, &block); end"
+    end
+
+    alias << info
+    alias unknown info
+
+    def noop(*); true end
+    %w[add
+      clone
+      datetime_format
+      datetime_format=
+      debug?
+      info?
+      error?
+      fatal?
+      warn?
+      level
+      level=
+      progname
+      progname=
+      sev_threshold
+      sev_threshold=
+    ].each do |op|
+      alias_method(op, :noop)
+    end
+  end
+end end

data/lib/u-log/rack_logger.rb

@@ -0,0 +1,39 @@
+require 'rack/commonlogger'
+
+module U; module Log
+  class RackLogger < Rack::CommonLogger
+    # In development mode the common logger is always inserted
+    def self.silence_common_logger!
+      Rack::CommonLogger.module_eval('def call(env); @app.call(env); end')
+      self
+    end
+
+    def initialize(app, logger)
+      @app = app
+      @logger = logger
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Rack::Utils::HeaderHash.new(header)
+      body = Rack::BodyProxy.new(body) { log(env, status, header, began_at) }
+      [status, header, body]
+    end
+
+    protected
+
+    def log(env, status, header, began_at)
+      @logger.log(
+        remote_addr: env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'],
+        remote_user: env['REMOTE_USER'] || '',
+        method: env['REQUEST_METHOD'],
+        path: env['PATH_INFO'],
+        query: env['QUERY_STRING'],
+        status: status.to_s[0..3],
+        length: extract_content_length(header),
+        elapsed: [Time.now - began_at, 's'],
+      )
+    end
+  end
+end end

data/lib/u-log/version.rb

@@ -0,0 +1,3 @@
+module U; module Log
+  VERSION = "0.1.0"
+end

data/test/u-log_test.rb

@@ -0,0 +1,23 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'minitest/autorun'
+require 'stringio'
+
+require 'u-log'
+
+class U_LoggerTest < MiniTest::Spec
+  include U::Log
+  NL = "\n"
+
+  def setup
+    @out = StringIO.new
+    @ctx = Logger.new(@out, Lines, {})
+  end
+
+  describe 'context' do
+    it 'does stuff' do
+      @ctx.log('hello')
+      assert_equal 'msg=hello' + NL, @out.string
+    end
+  end
+end

data/u-log.gemspec

@@ -0,0 +1,19 @@
+# coding: utf-8
+Gem::Specification.new do |spec|
+  spec.name          = "u-log"
+  spec.version       = "0.0.1"
+  spec.authors       = ["zimbatm"]
+  spec.email         = ["zimbatm@zimbatm.com"]
+  spec.summary       = %q{a different take on logging}
+  spec.description   = %q{U::Logger is a very simple logging library made for humans}
+  spec.homepage      = 'https://github.com/zimbatm/u-logger'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_runtime_dependency "lines"
+
+  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: u-log
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- zimbatm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: U::Logger is a very simple logging library made for humans
+email:
+- zimbatm@zimbatm.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- bench_concat.rb
+- lib/u-log.rb
+- lib/u-log/active_record.rb
+- lib/u-log/compat.rb
+- lib/u-log/rack_logger.rb
+- lib/u-log/version.rb
+- test/u-log_test.rb
+- u-log.gemspec
+homepage: https://github.com/zimbatm/u-logger
+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.2.2
+signing_key: 
+specification_version: 4
+summary: a different take on logging
+test_files:
+- test/u-log_test.rb