notarius 0.1.0

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Frank Mitchell
+
+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,149 @@
+Notarius
+========
+
+Notarius is a logging library with opinions. The word "notarius" is
+Latin for "shorthand writer". To this end, Notarius does everything
+possible to encourage you to write short useful log messages. 
+
+ * Whitespace is converted to spaces.
+ * Lines are truncated to 140 characters.
+ * Timestamps are formatted as [ISO 8601][].
+ * Call stacks are easy to grep.
+ * Duplicate messages are discarded.
+
+Notarius does not want you to be happy now, while you're writing code.
+It wants the person reading your logs at 3am trying to figure out why
+your code doesn't work to be happy. If those happen to be the same
+person, Notarius would rather future you be happier.
+
+There is infinitely more future than there is now.
+
+Installation
+------------
+
+Notarius is packaged as a Ruby gem. You do `gem install notarius` from
+the command line to get it.
+
+Configuration
+-------------
+
+Notarius is namespaced. This lets multiple libraries use Notarius
+without clobbering each others logs.
+
+```ruby
+require 'notarius'
+
+Notarius.configure 'BIG' do |log|
+  log.file = '/var/log/notarius/notebook.log'
+end
+```
+
+If you try to log to the same file as another library, Notarius will
+yell at you and throw an exception. Notarius does not want you to
+obliterate someone else's carefully crafted logs. However, it will tell
+you what they've namespaced their logs so you can redirect them
+elsewhere.
+
+By default, Notarius doesn't log to anything, not even the console. If
+you want console logging, you have to enable it.
+
+```ruby
+Notarius.configure 'BIG' do |log|
+  log.console = true
+end
+```
+
+Notarius is fine with you calling the `configure` method multiple times.
+This means you can set up defaults when your program starts and change
+them later.
+
+Usage
+-----
+
+Using Notarius is simple. Include the `Notarius::NAME` module (where
+NAME is the string you passed to the `configure` method) and call
+`log.info`, `log.warn`, or `log.error`. You can log anything that
+responds to `:message`, `:backtrace`, or `:inspect`.
+
+```ruby
+class Player 
+  include Notarius::BIG
+
+  def move direction
+    log.info "You head off down the #{direction} path."
+  end
+
+  def poke object
+    log.warn "Gingerly, you nudge the #{object}."
+  end
+
+  def attack monster 
+    if monster.nil?
+      log.error "You attack the darkness."
+    else
+      log.info "You whack the #{monster} with a stick."
+    end
+  end
+end
+```
+
+Opinions
+--------
+
+Notarius only has three logging levels: info, warning, and error. You
+don't need more than that. If think you do, your logs are too verbose.
+
+There is one line of output per message. If you insert carriage returns
+and newlines in a message, they will be converted into spaces. The same
+goes for tabs. Log statements shouldn't read like poetry. Exceptions are
+the exceptional exception to this rule.
+
+Messages are truncated so the total length of a line is less than 140
+characters. This makes them easy to [tweet][]. Tweetablility is
+important, because it's what the people reading logs at 3am do when they
+find something hilarious. If you're writing non-tweetable messages, your
+logs are too verbose.
+
+To make it easy to grep for warnings and errors, messages are output as
+"level [timestamp] message". You can do `cat notarius.log | grep ^WARN`
+and find all the warnings in a log.
+
+If the object you pass to the `log.info`, `log.warn`, and `log.error`
+methods responds to `:message` and `:backtrace`, you'll get output like
+this:
+
+```bash
+level [timestamp] message
+! backtrace
+! backtrace
+! backtrace 
+```
+
+This makes it easy to log exceptions. More importantly, it makes it easy
+to find exceptions: `cat notarius.log | grep -B 1 "^\!"`
+
+If you try to write the same message multiple times, only the first one
+will show up. This is true even if you change the logging level, or the
+timestamps of the messages are different. Multiple identical lines in
+the log are a sign that your code is broken.
+
+Inspiration
+-----------
+
+At lot of the Notarius philosophy was copied from [Logula][]. The
+rest of it comes from several years watching sysadmins work, and
+realizing that programmers often make their lives more difficult than we
+intend.
+
+Notarius tries to make things easier.
+
+License
+-------
+
+Notarius is available under an [MIT-style][] license. See the
+{file:LICENSE.md} document for more information.
+
+[Logula]: https://github.com/codahale/logula "Logula is a Scala library which provides a sane log output format and easy-to-use mixin for adding logging to your code."
+[MIT-style]:  http://opensource.org/license/MIT "Open Source Initiative OSI - The MIT License"
+[ISO 8601]: http://en.wikipedia.org/wiki/ISO_8601 "An international standard covering the exchange of date and time related data."
+[tweet]: https://twitter.com/ "Twitter"

data/lib/notarius.rb

@@ -0,0 +1,82 @@
+require 'notarius/secretary'
+require 'notarius/config'
+require 'notarius/exception'
+require 'notarius/version'
+
+module Notarius
+  @configs = {}
+
+  ##
+  # Configure logging for the named module.
+  #
+  # @yieldparam log [Config]
+  #
+  # @example
+  #   Notarius.configure 'BIG' do |log|
+  #     log.console = true
+  #     log.file = '/var/log/notarius/big.log'
+  #   end
+
+  def self.configure name, &block
+    name = namespace name
+    @configs[name] = Config.new if @configs[name].nil?
+    @configs[name].instance_eval(&block) if block_given?
+    return if self.const_defined? name
+
+    mod = Module.new do
+      define_method :log do
+        @secretary = Secretary.new if @secretary.nil?
+        @secretary.configure Notarius.config(name)
+        @secretary
+      end
+    end
+    self.const_set name, mod
+  end
+
+  ##
+  # Return a config with the given name. Validates the config first.
+  # @return [Config, nil] matching config or +nil+ if none found
+  # @see Notarius.validate
+
+  def self.config name
+    validate name
+    @configs[name]
+  end
+
+  ##
+  # Validate a config with the given name.
+  # @param [String] name name of config to validate
+  # @raise [Exception] when file is already being logged to
+
+  def self.validate name
+    config = @configs[name]
+    if config
+      @configs.each do |n, c|
+        if n != name && c.file && c.file == config.file
+          message = <<EOF
+Notarius::#{name} logs to the same file as Notarius::#{n}.
+EOF
+          raise Notarius::Exception.new message
+        end
+      end
+    end
+  end
+  private_class_method :validate
+
+  ##
+  # Convert an +Object+ to a +String+ that can be used as a namespace.
+  # This has to generate something that matches Ruby's idea of a
+  # constant.
+  # @raise [Exception] when +name+ is empty
+  # @param [#to_s] name name of the namespace
+  # @return [String] converted namespace
+
+  def self.namespace name
+    name = name.to_s
+    if name.empty?
+      raise Notarius::Exception.new "namespaces can't be empty"
+    end
+    name[0, 1].upcase + name[1, name.size]
+  end
+  private_class_method :namespace
+end

data/lib/notarius/config.rb

@@ -0,0 +1,6 @@
+module Notarius
+  class Config
+    attr_accessor :console
+    attr_accessor :file
+  end
+end

data/lib/notarius/exception.rb

@@ -0,0 +1,4 @@
+module Notarius
+  class Exception < ::Exception
+  end
+end

data/lib/notarius/formatter.rb

@@ -0,0 +1,72 @@
+require 'time'
+
+module Notarius
+  ##
+  # Handles formatting of log messages. It's compatable with Ruby's 
+  # +Logger::Formatter+ class, but has its own opinions:
+  #
+  # * Whitespace in the message is converted to spaces.
+  # * Output is truncated to 140 characters. 
+  # * Timestamps are formatted as ISO 8601 in UTC.
+  # * Lines in call stacks are prefixed with !'s.
+  # * Any of the arguments to #call can be nil.
+
+  class Formatter
+    ##
+    # This is the interface Ruby's +Logger+ class expects.
+    # @param [String] severity the severity level of the message
+    # @param [Date] timestamp the timestamp for the message
+    # @param [Object] application unused
+    # @param [String, #message, #backtrace, #inspect] message
+    #   the message to log
+    # @return [String] formatted as "SEVERITY [timestamp] message\\n"
+
+    def call severity, timestamp, application, message
+      result = []
+      result << format_severity(severity) if severity
+      result << '[' + format_timestamp(timestamp) + ']' if timestamp
+      result << format_message(message) if message
+      make_tweetable(result.join(' ')) + "\n"
+    end
+
+    def format_severity severity
+      severity.strip.upcase
+    end
+    private :format_severity
+
+    def format_message message 
+      result = []
+      if message.respond_to?(:message)
+        result << message.message
+      else
+        result << message
+      end
+      if message.respond_to?(:backtrace)
+        backtrace = [message.backtrace]
+        backtrace.flatten!
+        backtrace.compact!
+        result << backtrace.map { |line| "! %s" % clean_message(line) }
+      end
+      result.flatten!
+      result.map! { |line| clean_message(line) }
+      result.join("\n")
+    end
+    private :format_message
+
+    def clean_message message
+      message = message.inspect unless message.kind_of?(String)
+      message.gsub(/[\t\r\n\s]+/, ' ').strip
+    end
+    private :clean_message
+
+    def format_timestamp timestamp 
+      timestamp.utc.iso8601
+    end
+    private :format_timestamp
+
+    def make_tweetable message
+      message.length > 140 ? message[0, 137] + '...' : message
+    end
+    private :make_tweetable
+  end
+end

data/lib/notarius/secretary.rb

@@ -0,0 +1,88 @@
+require 'notarius/formatter'
+require 'logger'
+
+module Notarius
+  class Secretary
+    ##
+    # Create a new instance of Secretary.
+    # @return [Secretary]
+
+    def initialize
+      @loggers = {}
+      @messages = {}
+    end
+
+    ##
+    # Configure a Secretary.
+    # @param [Config] config the configuration for this Secretary
+    
+    def configure config
+      if config.console
+        add :console, logger(config.console, $stdout)
+      else
+        delete :console
+      end
+      if config.file
+        add :file, config.file
+      else
+        delete :file
+      end
+    end
+
+    ##
+    # Log an informative message. Informative messages show up the log
+    # with "INFO" at the start of the line.
+
+    def info message
+      log Logger::INFO, message
+    end
+
+    ##
+    # Log a warning message. Warning messages show up in the log with
+    # "WARN" at the start of the line.
+
+    def warn message
+      log Logger::WARN, message
+    end
+
+    ##
+    # Log an error message. Error messages show up in the log with
+    # "ERROR" at the start of the line.
+
+    def error message
+      log Logger::ERROR, message
+    end
+
+    def log severity, message
+      @loggers.each do |key, logger|
+        if message != @messages[key]
+          @messages[key] = message
+          logger.add(severity) { message }
+        end
+      end
+    end
+    private :log
+
+    def add key, stream
+      @loggers[key] = Logger.new stream
+      @loggers[key].formatter = Formatter.new
+    end
+    private :add
+
+    def delete key
+      logger = @loggers.delete(key)
+      logger.close rescue nil
+    end
+    private :delete
+
+    def logger *args
+      args.find { |arg| loggable?(arg) }
+    end
+    private :logger
+
+    def loggable? stream
+      stream.respond_to?(:write) && stream.respond_to?(:close)
+    end
+    private :loggable?
+  end
+end

data/lib/notarius/version.rb

@@ -0,0 +1,6 @@
+module Notarius
+  ##
+  # Semantic versioning makes life easier.
+
+  VERSION = '0.1.0'
+end

data/notarius.gemspec

@@ -0,0 +1,30 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+
+require 'notarius/version'
+
+Gem::Specification.new do |s|
+  s.name = 'notarius'
+  s.version = Notarius::VERSION
+  s.required_ruby_version = '~> 1.9'
+
+  s.summary = 'Notarius is a logging library with opinions.'
+  s.description = <<EOF
+Notarius is a logging library with opinions. The word "notarius" is
+Latin for "shorthand writer". To this end, Notarius does everything
+possible to encourage you to write short useful log messages.
+EOF
+
+  s.author = 'Frank Mitchell'
+  s.email = 'me@frankmitchell.org'
+  s.homepage = 'https://github.com/elimossinary/notarius'
+  s.license = 'MIT'
+
+  s.add_development_dependency 'rake', '~> 0.9.2'
+  s.add_development_dependency 'rspec', '~> 2.10'
+  s.add_development_dependency 'simplecov', '~> 0.6'
+
+  s.files = `git ls-files`.split("\n")
+  s.files.reject! { |file| file =~ /^\./ }
+
+  s.test_files = `git ls-files -- spec/*_spec.rb`.split("\n")
+end

data/rakefile.rb

@@ -0,0 +1,43 @@
+require 'rake/clean'
+require 'rspec/core/rake_task'
+
+CLEAN.include 'doc'
+CLEAN.include 'coverage'
+CLEAN.include '*.gem'
+CLEAN.include '.yardoc'
+
+desc 'Run specs.'
+task :default => :spec
+
+desc 'Run specs.'
+RSpec::Core::RakeTask.new :spec
+
+desc 'Generate SimpleCov spec coverage.'
+RSpec::Core::RakeTask.new :coverage do |t|
+  t.rspec_opts = ['--require simplecov_helper']
+end
+
+desc 'Build the gem.'
+task :build do
+  sh "gem build #{name}.gemspec"
+end
+
+desc 'Install the gem'
+task :install do
+  sh "gem install ./#{name}-#{version}.gem"
+end
+
+desc 'Uninstall the gem'
+task :uninstall do
+  sh "gem uninstall #{name}"
+end
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  text = File.read("lib/#{name}/version.rb")
+  text = text[/^\s*VERSION\s*=\s*.*/]
+  @version ||= text.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end

data/spec/config_spec.rb

@@ -0,0 +1,21 @@
+require 'notarius/config'
+
+describe Notarius::Config do
+  let(:config) { Notarius::Config.new }
+
+  it 'defaults to no console' do
+    config.console.should be_false
+  end
+
+  it 'defaults to no file' do
+    config.file.should be_false
+  end
+
+  it 'lets you configure a console' do
+    config.should respond_to(:console=)
+  end
+  
+  it 'lets you configure a file' do
+    config.should respond_to(:file=)
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,106 @@
+require 'notarius/formatter'
+
+describe Notarius::Formatter do
+  describe 'call' do
+    let(:formatter) { Notarius::Formatter.new }
+
+    it 'converts whitespace to spaces' do
+      message = "\sMessage\r\nwith\twhitespace  "
+      message = formatter.call(nil, nil, nil, message)
+      message.should == "Message with whitespace\n"
+    end
+
+    it 'formats timestamps as ISO 8601' do
+      timestamp = Time.parse('2012-06-25 20:41:30 -0400')
+      message = formatter.call(nil, timestamp, nil, nil)
+      message.should == "[2012-06-26T00:41:30Z]\n"
+    end
+
+    it 'makes severity all upper case' do
+      message = formatter.call('info', nil, nil, nil)
+      message.should == "INFO\n"
+    end
+
+    it 'removes extra whitespace from severity' do
+      message = formatter.call("\swarn\s", nil, nil, nil)
+      message.should == "WARN\n"
+    end
+
+    it 'ignores program name field' do
+      message = formatter.call(nil, nil, 'noodles', nil)
+      message.should == "\n"
+    end
+
+    it 'makes messages tweetable' do
+      message = <<-EOF
+      This is a really, really long message that needs to
+      be more than 140 characters so that Notarius can trim it
+      down to something more reasonable in length.
+      EOF
+      message.length.should > 140
+      message = formatter.call(nil, nil, nil, message)
+      message.strip.length.should == 140
+    end
+
+    it 'formats messages as "LEVEL [timestamp] message\n"' do
+      timestamp = Time.parse('2012-06-25 21:17:44 -0400')
+      message = formatter.call('level', timestamp, nil, 'message')
+      message.should == "LEVEL [2012-06-26T01:17:44Z] message\n"
+    end
+
+    it 'appends newlines to messages' do
+      message = formatter.call(nil, nil, nil, 'message')
+      message.should == "message\n"
+    end
+
+    it 'formats exceptions nicely' do
+      exception = Exception.new('message')
+      exception.set_backtrace ['trace this line', 'back to here'] 
+      lines = formatter.call(nil, nil, nil, exception).split("\n")
+      lines[0].should == 'message'
+      lines[1].should == '! trace this line'
+      lines[2].should == '! back to here'
+    end
+
+    it 'formats objects nicely' do
+      object = Class.new do
+        def inspect
+          'details'
+        end
+      end
+      message = formatter.call(nil, nil, nil, object.new)
+      message.should == "details\n"
+    end
+
+    it 'formats exceptions without backtraces nicely' do
+      exception = Exception.new('message')
+      message = formatter.call(nil, nil, nil, exception)
+      message.should == "message\n"
+    end
+
+    it 'formats objects that look like exceptions nicely' do
+      exception = Class.new do
+        def message
+          message = Class.new do
+            def inspect
+              'message'
+            end
+          end
+          message.new
+        end
+
+        def backtrace
+          backtrace = Class.new do
+            def inspect
+              'backtrace'
+            end
+          end
+          backtrace.new
+        end
+      end
+      lines = formatter.call(nil, nil, nil, exception.new).split("\n")
+      lines[0].should == 'message'
+      lines[1].should == '! backtrace'
+    end
+  end
+end

data/spec/notarius_spec.rb

@@ -0,0 +1,116 @@
+require 'notarius'
+require 'tempfile'
+
+describe Notarius do
+  def tempfiles *prefixes 
+    files = prefixes.map { |prefix| Tempfile.new prefix }
+    begin
+      paths = files.map { |file| file.path }
+      paths = paths.first if paths.size == 1
+      yield paths if block_given?
+    ensure
+      files.each { |file| file.close! }
+    end
+  end
+
+  it 'has a semantic version number' do
+    Notarius::VERSION.should match(/^\d+\.\d+\.\d+$/)
+  end
+
+  it 'can log to a file' do
+    tempfiles 'player' do |player_log|
+      Notarius.configure('BIG') { |l| l.file = player_log }
+      player = Class.new do
+        include Notarius::BIG
+        def initialize
+          log.info 'New player created!'
+        end
+      end
+      player.new
+      lines = File.read(player_log).split("\n")
+      lines[0].should end_with('New player created!')
+    end
+  end
+
+  it 'allows namespaces to be overwritten' do
+    tempfiles('player', 'monster') do |player_log, monster_log|
+      Notarius.configure('BIG') { |l| l.file = player_log }
+
+      player = Class.new do
+        include Notarius::BIG
+        def run message
+          log.info message
+        end
+      end
+      p = player.new
+
+      p.run 'Player is running.'
+      lines = File.read(player_log).split("\n")
+      lines[0].should end_with('Player is running.')
+
+      Notarius.configure('BIG') { |l| l.file = monster_log }
+      p.run 'Player is still running.'
+      lines = File.read(monster_log).split("\n")
+      lines[0].should end_with('Player is still running.')
+    end
+  end
+
+  it 'allows for unique namespaces' do
+    tempfiles('player', 'monster') do |player_log, monster_log|
+      Notarius.configure('Player') { |l| l.file = player_log }
+      player = Class.new do 
+        include Notarius::Player
+        def initialize
+          log.info 'New player created!'
+        end
+      end
+
+      Notarius.configure('Monster') { |l| l.file = monster_log }
+      monster = Class.new do
+        include Notarius::Monster
+        def initialize
+          log.info 'New monster created!'
+        end
+      end
+
+      monster.new
+      player.new
+      File.read(monster_log).should_not include('New player created!')
+    end
+  end
+
+  it 'throws an error if separate namespaces log to the same file' do
+    tempfiles 'log' do |log|
+      Notarius.configure('Player') { |l| l.file = log }
+      Notarius.configure('Monster') { |l| l.file = log }
+
+      monster = Class.new do
+        include Notarius::Monster
+        def initialize
+          log.info 'New monster created!'
+        end
+      end
+
+      expect { monster.new }.to raise_error(Notarius::Exception)
+    end
+  end
+
+  describe '#configure' do
+    it 'handles lowercase namespaces gracefully' do
+      Notarius.configure 'little'
+      Notarius.const_defined?(:Little).should be_true
+    end
+
+    it 'throws an error if a namespace is empty' do
+      expect do
+        Notarius.configure ''
+      end.to raise_error(Notarius::Exception)
+    end
+
+    it 'throws an error if a namespace is nil' do
+      expect do
+        Notarius.configure nil
+      end.to raise_error(Notarius::Exception)
+    end
+  end 
+end

data/spec/secretary_spec.rb

@@ -0,0 +1,128 @@
+require 'notarius/secretary'
+require 'stringio'
+
+describe Notarius::Secretary do
+  describe 'logging' do
+    let(:logger) { StringIO.new }
+    let(:secretary) do
+      c = Notarius::Config.new
+      c.file = logger
+      s = Notarius::Secretary.new
+      s.configure c
+      s
+    end
+
+    before :each do
+      logger.truncate 0
+      logger.rewind
+    end
+
+    it 'can log info messages' do
+      secretary.info 'info message'
+      logger.string.should match(/^INFO \[[^\]]+\] info message\n$/)
+    end
+
+    it 'can log warning messages' do
+      secretary.warn 'warning message'
+      logger.string.should match(/^WARN \[[^\]]+\] warning message\n$/)
+    end
+
+    it 'can log error messages' do
+      secretary.error 'error message'
+      logger.string.should match(/^ERROR \[[^\]]+\] error message\n$/)
+    end
+  end
+
+  describe '#configure' do
+    it 'logs to multiple outputs' do
+      io1 = StringIO.new
+      io2 = StringIO.new
+
+      secretary = Notarius::Secretary.new
+
+      config = Notarius::Config.new
+      config.console = io1
+      config.file = io2 
+      secretary.configure config
+
+      secretary.info 'info message'
+      io1.string.should match(/^INFO \[[^\]]+\] info message\n$/)
+      io2.string.should match(/^INFO \[[^\]]+\] info message\n$/)
+    end
+
+    it 'defaults console to stdout' do
+      config = Notarius::Config.new
+      config.console = true
+      secretary = Notarius::Secretary.new
+
+      output = StringIO.new
+      stdout = $stdout
+      begin
+        $stdout = output
+        secretary.configure config
+        secretary.info 'message'
+      ensure
+        $stdout = stdout 
+      end
+
+      output.string.should match(/^INFO \[[^\]]+\] message\n$/)
+    end
+
+    it 'removes a logger when no longer referenced' do
+      io1 = StringIO.new
+      io2 = StringIO.new
+
+      config1 = Notarius::Config.new
+      config1.console = io1
+      config1.file = io2
+
+      secretary = Notarius::Secretary.new
+      secretary.configure config1
+      secretary.info 'noodles'
+      io1.string.should match(/^INFO \[[^\]]+\] noodles\n$/)
+      io2.string.should match(/^INFO \[[^\]]+\] noodles\n$/)
+
+      secretary.configure Notarius::Config.new 
+      secretary.info 'pasta'
+      io1.string.should_not match(/^INFO \[[^\]]+\] pasta\n$/)
+      io2.string.should_not match(/^INFO \[[^\]]+\] pasta\n$/)
+    end
+
+    it 'closes a logger when it removes it' do
+      config = Notarius::Config.new
+      config.console = StringIO.new 
+
+      secretary = Notarius::Secretary.new
+      secretary.configure config
+      secretary.info 'noodles'
+      config.console.string.should match(/^INFO \[[^\]]+\] noodles\n$/)
+
+      secretary.configure Notarius::Config.new 
+      secretary.info 'pasta'
+      config.console.should be_closed
+    end
+  end
+
+  it 'skips duplicate messages per logger' do
+      io1 = StringIO.new
+      io2 = StringIO.new
+
+      secretary = Notarius::Secretary.new
+
+      config1 = Notarius::Config.new
+      config1.console = io1
+      secretary.configure config1
+
+      secretary.error 'same message'
+
+      config2 = Notarius::Config.new
+      config2.console = io1
+      config2.file = io2
+      secretary.configure config2
+
+      secretary.info 'same message'
+
+      io1.string.should_not match(/^INFO \[[^\]]+\] same message\n$/)
+      io2.string.should match(/^INFO \[[^\]]+\] same message\n$/)
+  end
+end

data/spec/simplecov_helper.rb

@@ -0,0 +1,2 @@
+require 'simplecov'
+SimpleCov.start

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: notarius
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Frank Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: ! 'Notarius is a logging library with opinions. The word "notarius" is
+
+  Latin for "shorthand writer". To this end, Notarius does everything
+
+  possible to encourage you to write short useful log messages.
+
+'
+email: me@frankmitchell.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/notarius.rb
+- lib/notarius/config.rb
+- lib/notarius/exception.rb
+- lib/notarius/formatter.rb
+- lib/notarius/secretary.rb
+- lib/notarius/version.rb
+- notarius.gemspec
+- rakefile.rb
+- spec/config_spec.rb
+- spec/formatter_spec.rb
+- spec/notarius_spec.rb
+- spec/secretary_spec.rb
+- spec/simplecov_helper.rb
+homepage: https://github.com/elimossinary/notarius
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Notarius is a logging library with opinions.
+test_files:
+- spec/config_spec.rb
+- spec/formatter_spec.rb
+- spec/notarius_spec.rb
+- spec/secretary_spec.rb
+has_rdoc: