lines 0.2.0 → 0.9.1

data/lib/lines/logger.rb

@@ -1,61 +0,0 @@
-module Lines
-  # Backward-compatible logger
-  # http://ruby-doc.org/stdlib-2.0/libdoc/logger/rdoc/Logger.html#method-i-log
-  class Logger
-    LEVELS = {
-      0 => :debug,
-      1 => :info,
-      2 => :warn,
-      3 => :error,
-      4 => :fatal,
-      5 => :unknown,
-    }
-
-    def initialize(line)
-      @line = line
-    end
-
-    def log(severity, message = nil, progname = nil, &block)
-      pri = LEVELS[severity] || severity
-      if block_given?
-        progname = message
-        message = yield.to_s rescue $!.to_s
-      end
-
-      data = { pri: pri }
-      data[:app] = progname if progname
-      data[:msg] = message if message
-
-      @line.log(data)
-    end
-
-    LEVELS.values.each do |level|
-      define_method(level) do |message=nil, &block|
-        log(level, message, &block)
-      end
-    end
-
-    alias << info
-    alias unknown info
-
-    def noop(*a); 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

data/lib/lines/rack_logger.rb

@@ -1,39 +0,0 @@
-require 'rack/commonlogger'
-require 'lines'
-
-module Lines
-  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)
-      @app = app
-    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)
-      Lines.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

data/spec/bench.rb

@@ -1,46 +0,0 @@
-require 'benchmark/ips'
-
-$:.unshift File.expand_path('../../lib', __FILE__)
-require 'lines'
-
-class FakeIO
-  def write(*a)
-  end
-  alias syswrite write
-end
-
-globals = {
-  app: 'benchmark',
-  at: proc{ Time.now },
-  pid: Process.pid,
-}
-
-EX = (raise "FOO" rescue $!)
-
-Benchmark.ips do |x|
-  x.report "FakeIO write" do |n|
-    Lines.use(FakeIO.new, globals)
-    n.times{ Lines.log EX }
-  end
-
-  x.report "/dev/null write" do |n|
-    dev_null = File.open('/dev/null', 'w')
-    Lines.use(dev_null, globals)
-    n.times{ Lines.log EX }
-  end
-
-  x.report "syslog write" do |n|
-    Lines.use(Syslog, globals)
-    n.times{ Lines.log EX }
-  end
-
-  x.report "real file" do |n|
-    real_file = File.open('real_file.log', 'w')
-    Lines.use(real_file, globals)
-    n.times{ Lines.log EX }
-  end
-
-  x.report "real file logger" do |n|
-    n.times{ Lines.logger.info "Ahoi this is a really cool option" }
-  end
-end

data/spec/lines_spec.rb

@@ -1,190 +0,0 @@
-require 'spec_helper'
-require 'lines'
-require 'stringio'
-
-NL = "\n"
-
-describe Lines do
-  let(:outputter) { StringIO.new }
-  let(:output) { outputter.string }
-  before do
-    Lines.use(outputter)
-  end
-
-  context ".log" do
-    it "logs stuff" do
-      Lines.log(foo: 'bar')
-      expect(output).to eq('foo=bar' + NL)
-    end
-
-    it "supports a first msg argument" do
-      Lines.log("this user is annoying", user: 'bob')
-      expect(output).to eq("msg='this user is annoying' user=bob" + NL)
-    end
-
-    it "logs exceptions" do
-      Lines.log(StandardError.new("error time!"), user: 'bob')
-      expect(output).to eq("ex=StandardError msg='error time!' user=bob" + NL)
-    end
-
-    it "logs exception backtraces when available" do
-      ex = (raise "foo" rescue $!)
-      #expect(ex).not_to eq(nil)
-      Lines.log(ex)
-      expect(output).to match(/ex=RuntimeError msg=foo backtrace=\[[^\]]+\]/)
-    end
-
-    it "works with anything" do
-      Lines.log("anything1", "anything2")
-      expect(output).to eq('msg=anything2' + NL)
-    end
-
-    it "doesn't convert nil args to msg" do
-      Lines.log("anything", nil)
-      expect(output).to eq('msg=anything' + NL)
-    end
-  end
-
-  context ".context" do
-    it "has contextes" do
-      Lines.context(foo: "bar").log(a: 'b')
-      expect(output).to eq('a=b foo=bar' + NL)
-    end
-
-    it "has contextes with blocks" do
-      Lines.context(foo: "bar") do |ctx|
-        ctx.log(a: 'b')
-      end
-      expect(output).to eq('a=b foo=bar' + NL)
-    end
-
-    it "mixes everything" do
-      Lines.global[:app] = :self
-      ctx = Lines.context(foo: "bar")
-      ctx.log('msg', ahoi: true)
-      expect(output).to eq('app=self msg=msg ahoi=#t foo=bar' + NL)
-    end
-  end
-
-  context ".logger" do
-    it "is provided for backward-compatibility" do
-      l = Lines.logger
-      l.info("hi")
-      expect(output).to eq('pri=info msg=hi' + NL)
-    end
-  end
-
-  context ".global" do
-    it "prepends data to the line" do
-      Lines.global["app"] = :self
-      Lines.log 'hey'
-      expect(output).to eq('app=self msg=hey' + NL)
-    end
-
-    it "resolves procs dynamically" do
-      count = 0
-      Lines.global[:count] = proc{ count += 1 }
-      Lines.log 'test1'
-      Lines.log 'test2'
-      expect(output).to eq(
-        'count=1 msg=test1' + NL +
-        'count=2 msg=test2' + NL
-      )
-    end
-
-    it "doesn't fail if a proc has an exception" do
-      Lines.global[:X] = proc{ fail "error" }
-      Lines.log 'test'
-      expect(output).to eq("X='#<RuntimeError: error>' msg=test" + NL)
-    end
-  end
-end
-
-describe Lines::Dumper do
-  subject { Lines::Dumper.new }
-  def expect_dump(obj)
-    expect(subject.dump obj)
-  end
-
-  it do
-    expect_dump(foo: 'bar').to eq('foo=bar')
-  end
-
-  it "dumps true, false and nil as #t, #f and nil" do
-    expect_dump(foo: true).to eq('foo=#t')
-    expect_dump(foo: false).to eq('foo=#f')
-    expect_dump(foo: nil).to eq('foo=nil')
-  end
-
-  it "dumps empty strings correclty" do
-    expect_dump(foo: '').to eq('foo=')
-  end
-
-  it "dumps a string with spaces surrounded by single quotes" do
-    expect_dump(foo: 'some" thing').to eq("foo='some\" thing'")
-  end
-
-  it "dumps a string with spaces and a single quote sourrounded with double quotes" do
-    expect_dump(foo: "foo ' bar").to eq("foo=\"foo ' bar\"")
-  end
-
-  it "can dump a basicobject" do
-    expect_dump(foo: BasicObject.new).to match(/foo='#<BasicObject:0x[0-9a-f]+>'/)
-  end
-
-  it "can dump IO objects" do
-    expect_dump(foo: File.open(__FILE__)).to match(/foo='?#<File:[^>]+>'?/)
-    expect_dump(foo: STDOUT).to match(/^foo='(?:#<IO:<STDOUT>>|#<IO:fd 1>)'$/)
-  end
-
-  it "dumps time as ISO zulu format" do
-    expect_dump(foo: Time.at(1337)).to eq('foo=1970-01-01T00:22:17Z')
-  end
-
-  it "dumps date as ISO date" do
-    expect_dump(foo: Date.new(1968, 3, 7)).to eq('foo=1968-03-07')
-  end
-
-  it "dumps symbols as strings" do
-    expect_dump(foo: :some_symbol).to eq('foo=some_symbol')
-    expect_dump(foo: :"some symbol").to eq("foo='some symbol'")
-  end
-
-  it "dumps numbers appropriately" do
-    expect_dump(foo: 10e3).to eq('foo=10000.0')
-    expect_dump(foo: 1).to eq('foo=1')
-    expect_dump(foo: -1).to eq('foo=-1')
-    # FIXME: don't put all the decimals
-    #expect_dump(foo: 4.0/3).to eq('foo=1.333')
-  end
-
-  it "dumps arrays appropriately" do
-    expect_dump(foo: [1,2,:a]).to eq('foo=[1 2 a]')
-  end
-
-  it "dumps [number, literal] tuples as numberliteral" do
-    expect_dump(foo: [3, :ms]).to eq('foo=3:ms')
-    expect_dump(foo: [54.2, 's']).to eq('foo=54.2:s')
-  end
-
-  it "knows how to handle circular dependencies" do
-    x = {}
-    x[:x] = x
-    expect_dump(x).to eq('x={x={x={x={...}}}}')
-  end
-end
-
-describe Lines::UniqueIDs do
-  include Lines::UniqueIDs
-
-  it "generates a unique ID" do
-    expect(id.size).to be > 1
-  end
-
-  it "generates a unique ID on each call" do
-    id1 = id
-    id2 = id
-    expect(id1).to_not eq(id2)
-  end
-
-end

data/spec/parse-bench

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-
-libdir = File.expand_path('../../lib', __FILE__)
-$:.unshift(libdir) unless $:.include? libdir
-
-require 'lines'
-
-loader = Lines.loader
-
-start = Time.now
-line_count = 0
-
-$stdin.lines.each do |line|
-  begin
-    line_count += 1
-    loader.load(line)
-  rescue Lines::Error => ex
-    # Lines seem to get truncated by syslog when too long
-    if line.size < 2000
-      p line
-      p ex
-    end
-  end
-end
-
-puts "Parsed #{line_count / (Time.now - start)} lines per second"