Merge lp:~rogpeppe/loggo/minor-fixes into lp:loggo

[Roger Peppe]

loggo: lots of minor changes

I've made quite a few changes here, mostly to make
things more Go idiomatic, to add documentation,
and hopefully to make things a bit cleaner and
in one or two cases a little more efficient.

I've added a final "f" onto all the Error, Warning, etc
functions so that they are amenable to checking with
govet. I've also taken out the special casing for no
arguments - if the first argument is a printf-like
format string, it should work as one regardless of
whether there are arguments or not.
If we want a more efficient version, we could add
Logger.Error(msg string) function or similar.

There seemed to be a general mixing of the term
"logger" and "module" so I have changed things
to standardise on "Logger" (as that's the type name)
and changed the Module method and some documentation
accordingly.

I've also made renamed ConfigureLogging to ConfigureLoggers
and DumpLoggingLevels to LoggerInfo and made ConfigureLoggers
understand the format produced by LoggerInfo, which seems
to me a fairly obvious thing to do. I've also made ConfigureLoggers
more tolerant of white space. I haven't in this branch, but in
a subsequent branch I am tempted to propose case insensitivity
throughout - I think that's actually a benefit, as well as
being more efficient. I think it would be best to standardise
on a single separator too - probably semicolon.

To go along with usual Go standards, I've also made functions
that parse stuff return an error if the parsing fails. I think it's
useful to be able to know if ConfigureLoggers is given an
invalid specification, for example.

I've changed the default formatting to print the time in UTC - if
we're not printing the time zone, I think that's important.
I'd quite like the default formatter to print millisecond resolution,
but that can wait.

Things I've thought of but have not done:
- We could make Logger a pointer type and lose the module type. It's
reasonable to say that a nil logger is equivalent to the root logger,
I think and get the same ok-to-use zero Logger semantics. YMMV about
that, so I left it for discussion.

- We could make ReplaceDefaultWriter more general, say ReplaceWriter,
because the functionality it provides (atomically replacing a writer)
is not possible to get otherwise - it's more than a convenience method.

Please feel free to say which things you don't like and I'll revert
those changes. In general I like the package quite a bit - thanks for doing it!

https://codereview.appspot.com/10043045/

[Roger Peppe (rogpeppe)]

Reviewers: mp+167832_code.launchpad.net,

Message:
Please take a look.

Description:
loggo: lots of minor changes

I've made quite a few changes here, mostly to make
things more Go idiomatic, to add documentation,
and hopefully to make things a bit cleaner and
in one or two cases a little more efficient.

I've added a final "f" onto all the Error, Warning, etc
functions so that they are amenable to checking with
govet. I've also taken out the special casing for no
arguments - if the first argument is a printf-like
format string, it should work as one regardless of
whether there are arguments or not.
If we want a more efficient version, we could add
Logger.Error(msg string) function or similar.

There seemed to be a general mixing of the term
"logger" and "module" so I have changed things
to standardise on "Logger" (as that's the type name)
and changed the Module method and some documentation
accordingly.

I've also made renamed ConfigureLogging to ConfigureLoggers
and DumpLoggingLevels to LoggerInfo and made ConfigureLoggers
understand the format produced by LoggerInfo, which seems
to me a fairly obvious thing to do. I've also made ConfigureLoggers
more tolerant of white space. I haven't in this branch, but in
a subsequent branch I am tempted to propose case insensitivity
throughout - I think that's actually a benefit, as well as
being more efficient. I think it would be best to standardise
on a single separator too - probably semicolon.

To go along with usual Go standards, I've also made functions
that parse stuff return an error if the parsing fails. I think it's
useful to be able to know if ConfigureLoggers is given an
invalid specification, for example.

I've changed the default formatting to print the time in UTC - if
we're not printing the time zone, I think that's important.
I'd quite like the default formatter to print millisecond resolution,
but that can wait.

Things I've thought of but have not done:
- We could make Logger a pointer type and lose the module type. It's
reasonable to say that a nil logger is equivalent to the root logger,
I think and get the same ok-to-use zero Logger semantics. YMMV about
that, so I left it for discussion.

- We could make ReplaceDefaultWriter more general, say ReplaceWriter,
because the functionality it provides (atomically replacing a writer)
is not possible to get otherwise - it's more than a convenience method.

Please feel free to say which things you don't like and I'll revert
those changes. In general I like the package quite a bit - thanks for
doing it!

https://code.launchpad.net/~rogpeppe/loggo/minor-fixes/+merge/167832

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/10043045/

Affected files:
   A [revision details]
   M formatter.go
   M logger.go
   M logger_test.go
   M writer.go
   M writer_test.go

=== modified file 'formatter.go'
--- formatter.go	2013-05-09 15:55:53 +0000
+++ formatter.go	2013-06-06 19:14:25 +0000
@@ -2,7 +2,7 @@
 
 import (
 	"fmt"
-	"path"
+	"path/filepath"
 	"time"
 )
 
@@ -12,15 +12,15 @@
 	Format(level Level, module, filename string, line int, timestamp time.Time, message string) string
 }
 
-// DefaultFormatter provides a simple concatination of all the components.
+// DefaultFormatter provides a simple concatenation of all the components.
 type DefaultFormatter struct{}
 
 // Format returns the parameters separated by spaces except for filename and
-// line which are separated by a colon.  The timestamp is only shown to second
-// resolution, and no timezone is shown.
+// line which are separated by a colon.  The timestamp is shown to second
+// resolution in UTC.
 func (*DefaultFormatter) Format(level Level, module, filename string, line int, timestamp time.Time, message string) string {
-	ts := timestamp.Format("2006-01-02 15:04:05")
+	ts := timestamp.In(time.UTC).Format("2006-01-02 15:04:05")
 	// Just get the basename from the filename
-	filename = path.Base(filename)
+	filename = filepath.Base(filename)
 	return fmt.Sprintf("%s %s %s %s:%d %s", ts, level, module, filename, line, message)
 }

=== modified file 'logger.go'
--- logger.go	2013-06-04 05:02:31 +0000
+++ logger.go	2013-06-06 19:14:25 +0000
@@ -3,14 +3,14 @@
 // This package provides an alternative to the standard library log package.
 //
 // The actual logging functions never return errors.  If you are logging
-// something, you really don't want to be worried about the actual logging
+// something, you really don't want to be worried about the logging
 // having trouble.
 //
 // Modules have names that are defined by dotted strings.
 //   e.g.  "first.second.third"
 //
-// There is a root module that is reflected by the name "".  Each module
-// (except the root module) has a parent, that is identified by the part of
+// There is a root module that has the name "".  Each module
+// (except the root module) has a parent, identified by the part of
 // the name without the last dotted value.
 //   e.g. the parent of "first.second.third" is "first.second"
 //        the parent of "first.second" is "first"
@@ -23,8 +23,9 @@
 // Loggers are created using the GetLogger function.
 //   e.g. logger := loggo.GetLogger("foo.bar")
 //
-// By default there is one writer registered, which will write to Stderr, and
-// only emit warnings and above.  If you want to continue using the default
+// By default there is one writer registered, which will write to Stderr,
+// and the root module, which will only emit warnings and above.
+// If you want to continue using the default
 // logger, but have it emit all logging levels you need to do the following.
 //
 //   writer, _, err := loggo.RemoveWriter("default")
@@ -42,10 +43,13 @@
 	"time"
 )
 
+// Level holds a severity level.
 type Level uint32
 
+// The severity levels. Higher values are more considered more
+// important.
 const (
-	NOT_SPECIFIED Level = iota
+	UNSPECIFIED Level = iota
 	TRACE
 	DEBUG
 	INFO
@@ -54,7 +58,13 @@
 	CRITICAL
 )
 
-// A Logger with a null impl pointer is effectively a root logger.
+// A Logger represents a logging module. It has an associated logging
+// level which can be changed; messages of lesser severity will
+// be dropped. Loggers have a hierarchical relationship - see
+// the package documentation.
+//
+// The zero Logger value is usable - any messages logged
+// to it will be sent to the root Logger.
 type Logger struct {
 	impl *module
 }
@@ -67,7 +77,7 @@
 
 // Initially the modules map only contains the root module.
 var (
-	root         = &module{"", WARNING, nil}
+	root         = &module{level: WARNING}
 	modulesMutex sync.Mutex
 	modules      = map[string]*module{
 		"": root,
@@ -76,8 +86,8 @@
 
 func (level Level) String() string {
 	switch level {
-	case NOT_SPECIFIED:
-		return "NOT_SPECIFIED"
+	case UNSPECIFIED:
+		return "UNSPECIFIED"
 	case TRACE:
 		return "TRACE"
 	case DEBUG:
@@ -94,24 +104,35 @@
 	return "<unknown>"
 }
 
+// get atomically gets the value of the given level.
+func (level *Level) get() Level {
+	return Level(atomic.LoadUint32((*uint32)(level)))
+}
+
+// set atomically sets the value of the receiver
+// to the given level.
+func (level *Level) set(newLevel Level) {
+	atomic.StoreUint32((*uint32)(level), uint32(newLevel))
+}
+
 // getLoggerInternal assumes that the modulesMutex is locked.
 func getLoggerInternal(name string) Logger {
 	impl, found := modules[name]
 	if found {
 		return Logger{impl}
 	}
-
-	parent := root
-	// Really wanting rsplit.
-	parts := strings.Split(name, ".")
-	if len(parts) > 1 {
-		parent = getLoggerInternal(strings.Join(parts[:len(parts)-1], ".")).impl
+	parentName := ""
+	if i := strings.LastIndex(name, "."); i >= 0 {
+		parentName = name[0:i]
 	}
-	impl = &module{name, NOT_SPECIFIED, parent}
+	parent := getLoggerInternal(parentName).impl
+	impl = &module{name, UNSPECIFIED, parent}
 	modules[name] = impl
 	return Logger{impl}
 }
 
+// GetLogger returns a Logger for the given module name,
+// creating it and its parents if necessary.
 func GetLogger(name string) Logger {
 	// Lowercase the module name, and look for it in the modules map.
 	name = strings.ToLower(name)
@@ -120,7 +141,11 @@
 	return getLoggerInternal(name)
 }
 
-func DumpLoggingLevels() string {
+// LoggerInfo returns information about the configured loggers and their logging
+// levels.  The information is returned in the format expected by
+// ConfigureModules. Loggers with UNSPECIFIED level will not
+// be included.
+func LoggerInfo() string {
 	output := []string{}
 	// output in alphabetical order.
 	keys := []string{}
@@ -133,67 +158,86 @@
 	for _, name := range keys {
 		mod := modules[name]
 		severity := mod.level
-		if severity == NOT_SPECIFIED {
+		if severity == UNSPECIFIED {
 			continue
 		}
-		module_name := mod.name
-		if module_name == "" {
-			module_name = "<root>"
-		}
-		output = append(output, fmt.Sprintf("%s %s", module_name, severity))
+		output = append(output, fmt.Sprintf("%s=%s", mod.Name(), severity))
 	}
-	return strings.Join(output, "\n")
+	return strings.Join(output, ";")
 }
 
-func ConfigureLogging(configString string) {
-	if configString == "" {
-		return
+// ConfigureLoggers configures loggers according to the given string
+// specification, which specifies a set of modules and their associated
+// logging levels.  Loggers are colon- or semicolon-separated; each
+// module is specified as <modulename>=<level>.  White space outside of
+// module names and levels is ignored.  The root module is specified
+// with the name "<root>".
+//
+// An example specification:
+//	`<root>=ERROR; foo.bar=WARNING`
+func ConfigureLoggers(specification string) error {
+	if specification == "" {
+		return nil
 	}
-
-	values := strings.FieldsFunc(configString, func(r rune) bool { return r == ';' || r == ':' })
+	values := strings.FieldsFunc(specification, func(r rune) bool { return r == ';' || r == ':' })
+	levels := make(map[string]Level)
 	for _, value := range values {
 		s := strings.SplitN(value, "=", 2)
 		if len(s) < 2 {
-			continue
-		}
-		name := s[0]
-		level := s[1]
+			return fmt.Errorf("logger specification expected '=', found %q", value)
+		}
+		name := strings.TrimSpace(s[0])
+		levelStr := strings.TrimSpace(s[1])
+		if name == "" || levelStr == "" {
+			return fmt.Errorf("logger specification %q has blank name or level", value)
+		}
 		if name == "<root>" {
 			name = ""
 		}
-		logger := GetLogger(name)
-		logger.SetLogLevel(GetLoggingLevel(level))
-	}
+		level, ok := ParseLevel(levelStr)
+		if !ok {
+			return fmt.Errorf("unknown severity level %q", levelStr)
+		}
+		levels[name] = level
+	}
+	for name, level := range levels {
+		GetLogger(name).SetLogLevel(level)
+	}
+	return nil
 }
 
 // ResetLogging iterates through the known modules and sets the levels of all
-// to NOT_SPECIFIED, except for <root> which is set to WARNING.
-func ResetLogging() {
+// to UNSPECIFIED, except for <root> which is set to WARNING.
+func ResetLoggers() {
 	modulesMutex.Lock()
 	defer modulesMutex.Unlock()
 	for _, module := range modules {
-		module.level = NOT_SPECIFIED
+		module.level = UNSPECIFIED
 	}
 	root.level = WARNING
 }
 
-// GetLoggingLevel converts a string representation of a logging level to the
-// enumerated value.
-func GetLoggingLevel(level string) Level {
+// ParseLevel converts a string representation of a logging level to a
+// Level. It returns the level and whether it was valid or not.
+func ParseLevel(level string) (Level, bool) {
 	level = strings.ToUpper(level)
 	switch level {
+	case "UNSPECIFIED":
+		return UNSPECIFIED, true
 	case "TRACE":
-		return TRACE
+		return TRACE, true
 	case "DEBUG":
-		return DEBUG
+		return DEBUG, true
 	case "INFO":
-		return INFO
+		return INFO, true
 	case "WARN", "WARNING":
-		return WARNING
+		return WARNING, true
 	case "ERROR":
-		return ERROR
+		return ERROR, true
+	case "CRITICAL":
+		return CRITICAL, true
 	}
-	return WARNING
+	return UNSPECIFIED, false
 }
 
 func (logger Logger) getModule() *module {
@@ -203,36 +247,66 @@
 	return logger.impl
 }
 
-func (logger Logger) Module() string {
-	return logger.getModule().name
+// Name returns the logger's module name.
+func (logger Logger) Name() string {
+	return logger.getModule().Name()
 }
 
-func (logger Logger) GetLogLevel() Level {
-	return Level(atomic.LoadUint32((*uint32)(&logger.getModule().level)))
+// LogLevel returns the configured log level of the logger.
+func (logger Logger) LogLevel() Level {
+	return logger.getModule().level.get()
 }
 
 func (module *module) getEffectiveLogLevel() Level {
-	level := Level(atomic.LoadUint32((*uint32)(&module.level)))
-	if level == NOT_SPECIFIED && module.parent != nil {
-		return module.parent.getEffectiveLogLevel()
-	}
-	return level
-}
-
-func (logger Logger) GetEffectiveLogLevel() Level {
+	// Note: the root module is guaranteed to have a
+	// specified logging level, so acts as a suitable sentinel
+	// for this loop.
+	for {
+		if level := module.level.get(); level != UNSPECIFIED {
+			return level
+		}
+		module = module.parent
+	}
+	panic("unreachable")
+}
+
+func (module *module) Name() string {
+	if module.name == "" {
+		return "<root>"
+	}
+	return module.name
+}
+
+// EffectiveLogLevel returns the effective log level of
+// the receiver - that is, messages with a lesser severity
+// level will be discarded.
+//
+// If the log level of the receiver is unspecified,
+// it will be taken from the effective log level of its
+// parent.
+func (logger Logger) EffectiveLogLevel() Level {
 	return logger.getModule().getEffectiveLogLevel()
 }
 
+// SetLogLevel sets the severity level of the given logger.
+// The root logger cannot be set to UNSPECIFIED level.
+// See EffectiveLogLevel for how this affects the
+// actual messages logged.
 func (logger Logger) SetLogLevel(level Level) {
 	module := logger.getModule()
 	// The root module can't be unspecified.
-	if module.name == "" && level == NOT_SPECIFIED {
+	if module.name == "" && level == UNSPECIFIED {
 		level = WARNING
 	}
-	atomic.StoreUint32((*uint32)(&module.level), uint32(level))
+	module.level.set(level)
 }
 
-func (logger Logger) Log(level Level, message string, args ...interface{}) {
+// Logf logs a printf-formatted message at the given level.
+// A message will be discarded if level is less than the
+// the effective log level of the logger.
+// Note that the writers may also filter out messages that
+// are less than their registered minimum severity level.
+func (logger Logger) Logf(level Level, message string, args ...interface{}) {
 	if logger.getModule().getEffectiveLogLevel() > level ||
 		!WillWrite(level) ||
 		level < TRACE ||
@@ -241,8 +315,6 @@
 	}
 	// Gather time, and filename, line number.
 	now := time.Now() // get this early.
-	var file string
-	var line int
 	// Param to Caller is the call depth.  Since this method is called from
 	// the Logger methods, we want the place that those were called from.
 	_, file, line, ok := runtime.Caller(2)
@@ -250,54 +322,78 @@
 		file = "???"
 		line = 0
 	}
+	// Trim newline off format string, following usual
+	// Go logging conventions.
+	if len(message) > 0 && message[len(message)-1] == '\n' {
+		message = message[0 : len(message)-1]
+	}
 
-	formattedMessage := message
-	if len(args) > 0 {
-		formattedMessage = fmt.Sprintf(message, args...)
-	}
+	formattedMessage := fmt.Sprintf(message, args...)
 	writeToWriters(level, logger.impl.name, file, line, now, formattedMessage)
 }
 
-func (logger Logger) Critical(message string, args ...interface{}) {
-	logger.Log(CRITICAL, message, args...)
-}
-
-func (logger Logger) Error(message string, args ...interface{}) {
-	logger.Log(ERROR, message, args...)
-}
-
-func (logger Logger) Warning(message string, args ...interface{}) {
-	logger.Log(WARNING, message, args...)
-}
-
-func (logger Logger) Info(message string, args ...interface{}) {
-	logger.Log(INFO, message, args...)
-}
-
-func (logger Logger) Debug(message string, args ...interface{}) {
-	logger.Log(DEBUG, message, args...)
-}
-
-func (logger Logger) Trace(message string, args ...interface{}) {
-	logger.Log(TRACE, message, args...)
-}
-
+// Criticalf logs the printf-formatted message at critical level.
+func (logger Logger) Criticalf(message string, args ...interface{}) {
+	logger.Logf(CRITICAL, message, args...)
+}
+
+// Criticalf logs the printf-formatted message at error level.
+func (logger Logger) Errorf(message string, args ...interface{}) {
+	logger.Logf(ERROR, message, args...)
+}
+
+// Criticalf logs the printf-formatted message at warning level.
+func (logger Logger) Warningf(message string, args ...interface{}) {
+	logger.Logf(WARNING, message, args...)
+}
+
+// Criticalf logs the printf-formatted message at info level.
+func (logger Logger) Infof(message string, args ...interface{}) {
+	logger.Logf(INFO, message, args...)
+}
+
+// Criticalf logs the printf-formatted message at debug level.
+func (logger Logger) Debugf(message string, args ...interface{}) {
+	logger.Logf(DEBUG, message, args...)
+}
+
+// Criticalf logs the printf-formatted message at trace level.
+func (logger Logger) Tracef(message string, args ...interface{}) {
+	logger.Logf(TRACE, message, args...)
+}
+
+// IsLevelEnabled returns whether debugging is enabled
+// for the given log level.
+func (logger Logger) IsLevelEnabled(level Level) bool {
+	return logger.getModule().getEffectiveLogLevel() <= level
+}
+
+// IsErrorEnabled returns whether debugging is enabled
+// at error level.
 func (logger Logger) IsErrorEnabled() bool {
-	return logger.getModule().getEffectiveLogLevel() <= ERROR
+	return logger.IsLevelEnabled(ERROR)
 }
 
+// IsWarningEnabled returns whether debugging is enabled
+// at warning level.
 func (logger Logger) IsWarningEnabled() bool {
-	return logger.getModule().getEffectiveLogLevel() <= WARNING
+	return logger.IsLevelEnabled(WARNING)
 }
 
+// IsInfoEnabled returns whether debugging is enabled
+// at info level.
 func (logger Logger) IsInfoEnabled() bool {
-	return logger.getModule().getEffectiveLogLevel() <= INFO
+	return logger.IsLevelEnabled(INFO)
 }
 
+// IsDebugEnabled returns whether debugging is enabled
+// at debug level.
 func (logger Logger) IsDebugEnabled() bool {
-	return logger.getModule().getEffectiveLogLevel() <= DEBUG
+	return logger.IsLevelEnabled(DEBUG)
 }
 
+// IsTraceEnabled returns whether debugging is enabled
+// at trace level.
 func (logger Logger) IsTraceEnabled() bool {
-	return logger.getModule().getEffectiveLogLevel() <= TRACE
+	return logger.IsLevelEnabled(TRACE)
 }

=== modified file 'logger_test.go'
--- logger_test.go	2013-06-04 03:37:54 +0000
+++ logger_test.go	2013-06-06 19:14:25 +0000
@@ -1,10 +1,8 @@
 package loggo_test
 
 import (
-	"fmt"
 	"io/ioutil"
 	"os"
-	"strings"
 	"testing"
 
 	. "launchpad.net/gocheck"
@@ -20,12 +18,12 @@
 var _ = Suite(&loggerSuite{})
 
 func (*loggerSuite) SetUpTest(c *C) {
-	loggo.ResetLogging()
+	loggo.ResetLoggers()
 }
 
 func (*loggerSuite) TestRootLogger(c *C) {
 	root := loggo.Logger{}
-	c.Assert(root.Module(), Equals, "")
+	c.Assert(root.Name(), Equals, "<root>")
 	c.Assert(root.IsErrorEnabled(), Equals, true)
 	c.Assert(root.IsWarningEnabled(), Equals, true)
 	c.Assert(root.IsInfoEnabled(), Equals, false)
@@ -35,54 +33,54 @@
 
 func (*loggerSuite) TestModuleName(c *C) {
 	logger := loggo.GetLogger("loggo.testing")
-	c.Assert(logger.Module(), Equals, "loggo.testing")
+	c.Assert(logger.Name(), Equals, "loggo.testing")
 }
 
 func (*loggerSuite) TestSetLevel(c *C) {
 	logger := loggo.GetLogger("testing")
 
-	c.Assert(logger.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.WARNING)
+	c.Assert(logger.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.WARNING)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, true)
 	c.Assert(logger.IsInfoEnabled(), Equals, false)
 	c.Assert(logger.IsDebugEnabled(), Equals, false)
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
 	logger.SetLogLevel(loggo.TRACE)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.TRACE)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.TRACE)
+	c.Assert(logger.LogLevel(), Equals, loggo.TRACE)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.TRACE)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, true)
 	c.Assert(logger.IsInfoEnabled(), Equals, true)
 	c.Assert(logger.IsDebugEnabled(), Equals, true)
 	c.Assert(logger.IsTraceEnabled(), Equals, true)
 	logger.SetLogLevel(loggo.DEBUG)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.DEBUG)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.DEBUG)
+	c.Assert(logger.LogLevel(), Equals, loggo.DEBUG)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.DEBUG)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, true)
 	c.Assert(logger.IsInfoEnabled(), Equals, true)
 	c.Assert(logger.IsDebugEnabled(), Equals, true)
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
 	logger.SetLogLevel(loggo.INFO)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.INFO)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.INFO)
+	c.Assert(logger.LogLevel(), Equals, loggo.INFO)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.INFO)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, true)
 	c.Assert(logger.IsInfoEnabled(), Equals, true)
 	c.Assert(logger.IsDebugEnabled(), Equals, false)
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
 	logger.SetLogLevel(loggo.WARNING)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.WARNING)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.WARNING)
+	c.Assert(logger.LogLevel(), Equals, loggo.WARNING)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.WARNING)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, true)
 	c.Assert(logger.IsInfoEnabled(), Equals, false)
 	c.Assert(logger.IsDebugEnabled(), Equals, false)
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
 	logger.SetLogLevel(loggo.ERROR)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.ERROR)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(logger.LogLevel(), Equals, loggo.ERROR)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.ERROR)
 	c.Assert(logger.IsErrorEnabled(), Equals, true)
 	c.Assert(logger.IsWarningEnabled(), Equals, false)
 	c.Assert(logger.IsInfoEnabled(), Equals, false)
@@ -90,16 +88,16 @@
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
 	// This is added for completeness, but not really expected to be used.
 	logger.SetLogLevel(loggo.CRITICAL)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.CRITICAL)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.CRITICAL)
+	c.Assert(logger.LogLevel(), Equals, loggo.CRITICAL)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.CRITICAL)
 	c.Assert(logger.IsErrorEnabled(), Equals, false)
 	c.Assert(logger.IsWarningEnabled(), Equals, false)
 	c.Assert(logger.IsInfoEnabled(), Equals, false)
 	c.Assert(logger.IsDebugEnabled(), Equals, false)
 	c.Assert(logger.IsTraceEnabled(), Equals, false)
-	logger.SetLogLevel(loggo.NOT_SPECIFIED)
-	c.Assert(logger.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(logger.GetEffectiveLogLevel(), Equals, loggo.WARNING)
+	logger.SetLogLevel(loggo.UNSPECIFIED)
+	c.Assert(logger.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(logger.EffectiveLogLevel(), Equals, loggo.WARNING)
 }
 
 func (*loggerSuite) TestLevelsSharedForSameModule(c *C) {
@@ -115,8 +113,8 @@
 	logger1 := loggo.GetLogger("TESTING.MODULE")
 	logger2 := loggo.GetLogger("Testing")
 
-	c.Assert(logger1.Module(), Equals, "testing.module")
-	c.Assert(logger2.Module(), Equals, "testing")
+	c.Assert(logger1.Name(), Equals, "testing.module")
+	c.Assert(logger2.Name(), Equals, "testing")
 }
 
 func (*loggerSuite) TestLevelsInherited(c *C) {
@@ -125,107 +123,193 @@
 	second := loggo.GetLogger("first.second")
 
 	root.SetLogLevel(loggo.ERROR)
-	c.Assert(root.GetLogLevel(), Equals, loggo.ERROR)
-	c.Assert(root.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(first.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(first.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(second.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(second.GetEffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(root.LogLevel(), Equals, loggo.ERROR)
+	c.Assert(root.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(first.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(first.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(second.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(second.EffectiveLogLevel(), Equals, loggo.ERROR)
 
 	first.SetLogLevel(loggo.DEBUG)
-	c.Assert(root.GetLogLevel(), Equals, loggo.ERROR)
-	c.Assert(root.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(first.GetLogLevel(), Equals, loggo.DEBUG)
-	c.Assert(first.GetEffectiveLogLevel(), Equals, loggo.DEBUG)
-	c.Assert(second.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(second.GetEffectiveLogLevel(), Equals, loggo.DEBUG)
+	c.Assert(root.LogLevel(), Equals, loggo.ERROR)
+	c.Assert(root.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(first.LogLevel(), Equals, loggo.DEBUG)
+	c.Assert(first.EffectiveLogLevel(), Equals, loggo.DEBUG)
+	c.Assert(second.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(second.EffectiveLogLevel(), Equals, loggo.DEBUG)
 
 	second.SetLogLevel(loggo.INFO)
-	c.Assert(root.GetLogLevel(), Equals, loggo.ERROR)
-	c.Assert(root.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(first.GetLogLevel(), Equals, loggo.DEBUG)
-	c.Assert(first.GetEffectiveLogLevel(), Equals, loggo.DEBUG)
-	c.Assert(second.GetLogLevel(), Equals, loggo.INFO)
-	c.Assert(second.GetEffectiveLogLevel(), Equals, loggo.INFO)
-
-	first.SetLogLevel(loggo.NOT_SPECIFIED)
-	c.Assert(root.GetLogLevel(), Equals, loggo.ERROR)
-	c.Assert(root.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(first.GetLogLevel(), Equals, loggo.NOT_SPECIFIED)
-	c.Assert(first.GetEffectiveLogLevel(), Equals, loggo.ERROR)
-	c.Assert(second.GetLogLevel(), Equals, loggo.INFO)
-	c.Assert(second.GetEffectiveLogLevel(), Equals, loggo.INFO)
-}
-
-func (*loggerSuite) TestGetLoggingLevel(c *C) {
-	c.Assert(loggo.GetLoggingLevel("trace"), Equals, loggo.TRACE)
-	c.Assert(loggo.GetLoggingLevel("TrAce"), Equals, loggo.TRACE)
-	c.Assert(loggo.GetLoggingLevel("TRACE"), Equals, loggo.TRACE)
-	c.Assert(loggo.GetLoggingLevel("debug"), Equals, loggo.DEBUG)
-	c.Assert(loggo.GetLoggingLevel("DEBUG"), Equals, loggo.DEBUG)
-	c.Assert(loggo.GetLoggingLevel("info"), Equals, loggo.INFO)
-	c.Assert(loggo.GetLoggingLevel("INFO"), Equals, loggo.INFO)
-	c.Assert(loggo.GetLoggingLevel("warn"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("WARN"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("warning"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("WARNING"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("error"), Equals, loggo.ERROR)
-	c.Assert(loggo.GetLoggingLevel("ERROR"), Equals, loggo.ERROR)
-	// Unknown levels result in WARNING
-	c.Assert(loggo.GetLoggingLevel("critical"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("not_specified"), Equals, loggo.WARNING)
-	c.Assert(loggo.GetLoggingLevel("other"), Equals, loggo.WARNING)
+	c.Assert(root.LogLevel(), Equals, loggo.ERROR)
+	c.Assert(root.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(first.LogLevel(), Equals, loggo.DEBUG)
+	c.Assert(first.EffectiveLogLevel(), Equals, loggo.DEBUG)
+	c.Assert(second.LogLevel(), Equals, loggo.INFO)
+	c.Assert(second.EffectiveLogLevel(), Equals, loggo.INFO)
+
+	first.SetLogLevel(loggo.UNSPECIFIED)
+	c.Assert(root.LogLevel(), Equals, loggo.ERROR)
+	c.Assert(root.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(first.LogLevel(), Equals, loggo.UNSPECIFIED)
+	c.Assert(first.EffectiveLogLevel(), Equals, loggo.ERROR)
+	c.Assert(second.LogLevel(), Equals, loggo.INFO)
+	c.Assert(second.EffectiveLogLevel(), Equals, loggo.INFO)
+}
+
+var parseLevelTests = []struct {
+	str   string
+	level loggo.Level
+	fail  bool
+}{{
+	str:   "trace",
+	level: loggo.TRACE,
+}, {
+	str:   "TrAce",
+	level: loggo.TRACE,
+}, {
+	str:   "TRACE",
+	level: loggo.TRACE,
+}, {
+	str:   "debug",
+	level: loggo.DEBUG,
+}, {
+	str:   "DEBUG",
+	level: loggo.DEBUG,
+}, {
+	str:   "info",
+	level: loggo.INFO,
+}, {
+	str:   "INFO",
+	level: loggo.INFO,
+}, {
+	str:   "warn",
+	level: loggo.WARNING,
+}, {
+	str:   "WARN",
+	level: loggo.WARNING,
+}, {
+	str:   "warning",
+	level: loggo.WARNING,
+}, {
+	str:   "WARNING",
+	level: loggo.WARNING,
+}, {
+	str:   "error",
+	level: loggo.ERROR,
+}, {
+	str:   "ERROR",
+	level: loggo.ERROR,
+}, {
+	str:   "critical",
+	level: loggo.CRITICAL,
+}, {
+	str:  "not_specified",
+	fail: true,
+}, {
+	str:  "other",
+	fail: true,
+}, {
+	str:  "",
+	fail: true,
+}}
+
+func (*loggerSuite) TestParseLevel(c *C) {
+	for _, test := range parseLevelTests {
+		level, ok := loggo.ParseLevel(test.str)
+		c.Assert(level, Equals, test.level)
+		c.Assert(ok, Equals, !test.fail)
+	}
+}
+
+var levelStringValueTests = map[loggo.Level]string{
+	loggo.UNSPECIFIED: "UNSPECIFIED",
+	loggo.DEBUG:       "DEBUG",
+	loggo.TRACE:       "TRACE",
+	loggo.INFO:        "INFO",
+	loggo.WARNING:     "WARNING",
+	loggo.ERROR:       "ERROR",
+	loggo.CRITICAL:    "CRITICAL",
+	loggo.Level(42):   "<unknown>", // other values are unknown
 }
 
 func (*loggerSuite) TestLevelStringValue(c *C) {
-	c.Assert(fmt.Sprint(loggo.NOT_SPECIFIED), Equals, "NOT_SPECIFIED")
-	c.Assert(fmt.Sprint(loggo.TRACE), Equals, "TRACE")
-	c.Assert(fmt.Sprint(loggo.DEBUG), Equals, "DEBUG")
-	c.Assert(fmt.Sprint(loggo.INFO), Equals, "INFO")
-	c.Assert(fmt.Sprint(loggo.WARNING), Equals, "WARNING")
-	c.Assert(fmt.Sprint(loggo.ERROR), Equals, "ERROR")
-	c.Assert(fmt.Sprint(loggo.CRITICAL), Equals, "CRITICAL")
-	// other values are unknown
-	c.Assert(fmt.Sprint(loggo.Level(42)), Equals, "<unknown>")
-}
-
-func (*loggerSuite) TestConfigureLoggingEmpty(c *C) {
-	root := loggo.GetLogger("")
-	root.SetLogLevel(loggo.DEBUG)
-	logger := loggo.GetLogger("test.module")
-	logger.SetLogLevel(loggo.INFO)
-	// Configure passed a null pointer does nothing.
-	loggo.ConfigureLogging("")
-	expected := `
-<root> DEBUG
-test.module INFO
-`
-	c.Assert(loggo.DumpLoggingLevels(), Equals, strings.TrimSpace(expected))
-}
-
-func (*loggerSuite) TestConfigureLoggingRoot(c *C) {
-	loggo.ConfigureLogging("<root>=debug")
-	c.Assert(loggo.DumpLoggingLevels(), Equals, "<root> DEBUG")
-}
-
-func (*loggerSuite) TestConfigureLoggingSingleModule(c *C) {
-	loggo.ConfigureLogging("test.module=debug")
-	expected := `
-<root> WARNING
-test.module DEBUG
-`
-	c.Assert(loggo.DumpLoggingLevels(), Equals, strings.TrimSpace(expected))
-}
-
-func (*loggerSuite) TestConfigureLoggingMultipleModules(c *C) {
-	loggo.ConfigureLogging("module=info;sub.module=debug:other.module=warning")
-	expected := `
-<root> WARNING
-module INFO
-other.module WARNING
-sub.module DEBUG
-`
-	c.Assert(loggo.DumpLoggingLevels(), Equals, strings.TrimSpace(expected))
+	for level, str := range levelStringValueTests {
+		c.Assert(level.String(), Equals, str)
+	}
+}
+
+var configureLoggersTests = []struct {
+	spec string
+	info string
+	err  string
+}{{
+	spec: "",
+	info: "<root>=WARNING",
+}, {
+	spec: "<root>=UNSPECIFIED",
+	info: "<root>=WARNING",
+}, {
+	spec: "<root>=DEBUG",
+	info: "<root>=DEBUG",
+}, {
+	spec: "test.module=debug",
+	info: "<root>=WARNING;test.module=DEBUG",
+}, {
+	spec: "module=info; sub.module=debug; other.module=warning",
+	info: "<root>=WARNING;module=INFO;other.module=WARNING;sub.module=DEBUG",
+}, {
+	spec: "  foo.bar \t\r\n= \t\r\nCRITICAL \t\r\n; \t\r\nfoo \r\t\n = DEBUG",
+	info: "<root>=WARNING;foo=DEBUG;foo.bar=CRITICAL",
+}, {
+	spec: "foo;bar",
+	info: "<root>=WARNING",
+	err:  `logger specification expected '=', found "foo"`,
+}, {
+	spec: "=foo",
+	info: "<root>=WARNING",
+	err:  `logger specification "=foo" has blank name or level`,
+}, {
+	spec: "foo=",
+	info: "<root>=WARNING",
+	err:  `logger specification "foo=" has blank name or level`,
+}, {
+	spec: "=",
+	info: "<root>=WARNING",
+	err:  `logger specification "=" has blank name or level`,
+}, {
+	spec: "foo=unknown",
+	info: "<root>=WARNING",
+	err:  `unknown severity level "unknown"`,
+}, {
+	// Test that nothing is changed even when the
+	// first part of the specification parses ok.
+	spec: "module=info; foo=unknown",
+	info: "<root>=WARNING",
+	err:  `unknown severity level "unknown"`,
+}}
+
+func (*loggerSuite) TestConfigureLoggers(c *C) {
+	for i, test := range configureLoggersTests {
+		c.Logf("test %d: %q", i, test.spec)
+		loggo.ResetLoggers()
+		err := loggo.ConfigureLoggers(test.spec)
+		c.Check(loggo.LoggerInfo(), Equals, test.info)
+		if test.err != "" {
+			c.Assert(err, ErrorMatches, test.err)
+			continue
+		}
+		c.Assert(err, IsNil)
+
+		// Test that it's idempotent.
+		err = loggo.ConfigureLoggers(test.spec)
+		c.Assert(err, IsNil)
+		c.Assert(loggo.LoggerInfo(), Equals, test.info)
+
+		// Test that calling ConfigureLoggers with the
+		// output of LoggerInfo works too.
+		err = loggo.ConfigureLoggers(test.info)
+		c.Assert(err, IsNil)
+		c.Assert(loggo.LoggerInfo(), Equals, test.info)
+	}
 }
 
 type logwriterSuite struct {
@@ -236,7 +320,7 @@
 var _ = Suite(&logwriterSuite{})
 
 func (s *logwriterSuite) SetUpTest(c *C) {
-	loggo.ResetLogging()
+	loggo.ResetLoggers()
 	loggo.RemoveWriter("default")
 	s.writer = &loggo.TestWriter{}
 	err := loggo.RegisterWriter("test", s.writer, loggo.TRACE)
@@ -251,27 +335,28 @@
 }
 
 func (s *logwriterSuite) TestLogDoesntLogWeirdLevels(c *C) {
-	s.logger.Log(loggo.NOT_SPECIFIED, "message")
-	c.Assert(s.writer.Log, HasLen, 0)
-
-	s.logger.Log(loggo.Level(42), "message")
-	c.Assert(s.writer.Log, HasLen, 0)
-
-	s.logger.Log(loggo.CRITICAL+loggo.Level(1), "message")
+	s.logger.Logf(loggo.UNSPECIFIED, "message")
+	c.Assert(s.writer.Log, HasLen, 0)
+
+	s.logger.Logf(loggo.Level(42), "message")
+	c.Assert(s.writer.Log, HasLen, 0)
+
+	s.logger.Logf(loggo.CRITICAL+loggo.Level(1), "message")
 	c.Assert(s.writer.Log, HasLen, 0)
 }
 
 func (s *logwriterSuite) TestMessageFormatting(c *C) {
-	s.logger.Log(loggo.INFO, "some % included")
+	s.logger.Logf(loggo.INFO, "some %s included", "formatting")
 	c.Assert(s.writer.Log, HasLen, 1)
-	c.Assert(s.writer.Log[0].Message, Equals, "some % included")
+	c.Assert(s.writer.Log[0].Message, Equals, "some formatting included")
+	c.Assert(s.writer.Log[0].Level, Equals, loggo.INFO)
 }
 
 func (s *logwriterSuite) BenchmarkLoggingNoWriters(c *C) {
 	// No writers
 	loggo.RemoveWriter("test")
 	for i := 0; i < c.N; i++ {
-		s.logger.Warning("just a simple warning for %d", i)
+		s.logger.Warningf("just a simple warning for %d", i)
 	}
 }
 
@@ -279,13 +364,13 @@
 	// No writers
 	loggo.RemoveWriter("test")
 	for i := 0; i < c.N; i++ {
-		s.logger.Warning("just a simple warning")
+		s.logger.Warningf("just a simple warning")
 	}
 }
 
 func (s *logwriterSuite) BenchmarkLoggingTestWriters(c *C) {
 	for i := 0; i < c.N; i++ {
-		s.logger.Warning("just a simple warning for %d", i)
+		s.logger.Warningf("just a simple warning for %d", i)
 	}
 	c.Assert(s.writer.Log, HasLen, c.N)
 }
@@ -309,7 +394,7 @@
 	defer cleanup()
 	msg := "just a simple warning for %d"
 	for i := 0; i < c.N; i++ {
-		s.logger.Warning(msg, i)
+		s.logger.Warningf(msg, i)
 	}
 	offset, err := logFile.Seek(0, os.SEEK_CUR)
 	c.Assert(err, IsNil)
@@ -326,7 +411,7 @@
 	loggo.RegisterWriter("testfile", writer, loggo.WARNING)
 	msg := "just a simple warning for %d"
 	for i := 0; i < c.N; i++ {
-		s.logger.Debug(msg, i)
+		s.logger.Debugf(msg, i)
 	}
 	offset, err := logFile.Seek(0, os.SEEK_CUR)
 	c.Assert(err, IsNil)
@@ -341,7 +426,7 @@
 	s.logger.SetLogLevel(loggo.WARNING)
 	msg := "just a simple warning for %d"
 	for i := 0; i < c.N; i++ {
-		s.logger.Debug(msg, i)
+		s.logger.Debugf(msg, i)
 	}
 	offset, err := logFile.Seek(0, os.SEEK_CUR)
 	c.Assert(err, IsNil)

=== modified file 'writer.go'
--- writer.go	2013-06-04 04:43:14 +0000
+++ writer.go	2013-06-06 19:14:25 +0000
@@ -5,12 +5,18 @@
 	"io"
 	"os"
 	"sync"
-	"sync/atomic"
 	"time"
 )
 
+// Writer is implemented by any recipient of log messages.
 type Writer interface {
-	Write(level Level, module, filename string, line int, timestamp time.Time, message string)
+	// Write writes a message to the Writer with the given
+	// level and module name. The filename and line hold
+	// the file name and line number of the code that is
+	// generating the log message; the time stamp holds
+	// the time the log message was generated, and
+	// message holds the log message itself.
+	Write(level Level, name, filename string, line int, timestamp time.Time, message string)
 }
 
 type registeredWriter struct {
@@ -18,17 +24,8 @@
 	level  Level
 }
 
-type SimpleWriter struct {
-	writer    io.Writer
-	formatter Formatter
-}
-
-// NewSimpleWriter creates a new simple writer with the specified log formatter.
-func NewSimpleWriter(writer io.Writer, formatter Formatter) Writer {
-	return &SimpleWriter{writer, formatter}
-}
-
-// The registered writers is an application level singleton.
+// defaultName is the name of a writer that is registered
+// by default that writes to stderr.
 const defaultName = "default"
 
 var (
@@ -56,8 +53,8 @@
 }
 
 // ReplaceDefaultWriter is a convenience method that does the equivalent of
-// RemoveWriter and then RegisterWriter with the name "default".  The existing
-// default writer is returned.
+// RemoveWriter and then RegisterWriter with the name "default".  The previous
+// default writer, if any is returned.
 func ReplaceDefaultWriter(writer Writer) (Writer, error) {
 	if writer == nil {
 		return nil, fmt.Errorf("Writer cannot be nil")
@@ -66,7 +63,7 @@
 	defer writerMutex.Unlock()
 	reg, found := writers[defaultName]
 	if !found {
-		return nil, fmt.Errorf("There is no %q writer", defaultName)
+		return nil, fmt.Errorf("there is no %q writer", defaultName)
 	}
 	oldWriter := reg.writer
 	reg.writer = writer
@@ -77,7 +74,7 @@
 // RegisterWriter adds the writer to the list of writers that get notified
 // when logging.  When registering, the caller specifies the minimum logging
 // level that will be written, and a name for the writer.  If there is already
-// a registered writer with that name, and error is returned.
+// a registered writer with that name, an error is returned.
 func RegisterWriter(name string, writer Writer, minLevel Level) error {
 	if writer == nil {
 		return fmt.Errorf("Writer cannot be nil")
@@ -85,7 +82,7 @@
 	writerMutex.Lock()
 	defer writerMutex.Unlock()
 	if _, found := writers[name]; found {
-		return fmt.Errorf("There is already a Writer registerd with the name %q", name)
+		return fmt.Errorf("there is already a Writer registered with the name %q", name)
 	}
 	writers[name] = &registeredWriter{writer: writer, level: minLevel}
 	findMinLevel()
@@ -99,7 +96,7 @@
 	defer writerMutex.Unlock()
 	registered, found := writers[name]
 	if !found {
-		return nil, NOT_SPECIFIED, fmt.Errorf("No registered Writer called %q", name)
+		return nil, UNSPECIFIED, fmt.Errorf("Writer %q is not registered", name)
 	}
 	delete(writers, name)
 	findMinLevel()
@@ -114,12 +111,14 @@
 			minLevel = registered.level
 		}
 	}
-	atomic.StoreUint32((*uint32)(&globalMinLevel), uint32(minLevel))
+	globalMinLevel.set(minLevel)
 }
 
-// Are there any writers that are interested in this log level?
+// WillWrite returns whether there are any writers registered
+// at or above the given severity level. If it returns
+// false, a log message at the given level will be discarded.
 func WillWrite(level Level) bool {
-	return level >= Level(atomic.LoadUint32((*uint32)(&globalMinLevel)))
+	return level >= globalMinLevel.get()
 }
 
 func writeToWriters(level Level, module, filename string, line int, timestamp time.Time, message string) {
@@ -132,7 +131,19 @@
 	}
 }
 
-func (simple *SimpleWriter) Write(level Level, module, filename string, line int, timestamp time.Time, message string) {
+type simpleWriter struct {
+	writer    io.Writer
+	formatter Formatter
+}
+
+// NewSimpleWriter returns a new writer that writes
+// log messages to the given io.Writer formatting the
+// messages with the given formatter.
+func NewSimpleWriter(writer io.Writer, formatter Formatter) Writer {
+	return &simpleWriter{writer, formatter}
+}
+
+func (simple *simpleWriter) Write(level Level, module, filename string, line int, timestamp time.Time, message string) {
 	logLine := simple.formatter.Format(level, module, filename, line, timestamp, message)
 	fmt.Fprintln(simple.writer, logLine)
 }

=== modified file 'writer_test.go'
--- writer_test.go	2013-06-02 10:40:23 +0000
+++ writer_test.go	2013-06-06 19:14:25 +0000
@@ -24,14 +24,14 @@
 
 	// Trying again fails.
 	defaultWriter, level, err = loggo.RemoveWriter("default")
-	c.Assert(err, ErrorMatches, `No registered Writer called "default"`)
-	c.Assert(level, Equals, loggo.NOT_SPECIFIED)
+	c.Assert(err, ErrorMatches, `Writer "default" is not registered`)
+	c.Assert(level, Equals, loggo.UNSPECIFIED)
 	c.Assert(defaultWriter, IsNil)
 }
 
 func (*writerBasicsSuite) TestRegisterWriterExistingName(c *C) {
 	err := loggo.RegisterWriter("default", &loggo.TestWriter{}, loggo.INFO)
-	c.Assert(err, ErrorMatches, `There is already a Writer registerd with the name "default"`)
+	c.Assert(err, ErrorMatches, `there is already a Writer registered with the name "default"`)
 }
 
 func (*writerBasicsSuite) TestRegisterNilWriter(c *C) {
@@ -62,7 +62,7 @@
 	loggo.RemoveWriter("default")
 	oldWriter, err := loggo.ReplaceDefaultWriter(&loggo.TestWriter{})
 	c.Assert(oldWriter, IsNil)
-	c.Assert(err, ErrorMatches, `There is no "default" writer`)
+	c.Assert(err, ErrorMatches, `there is no "default" writer`)
 }
 
 func (s *writerBasicsSuite) TestWillWrite(c *C) {
@@ -89,7 +89,7 @@
 var _ = Suite(&writerSuite{})
 
 func (s *writerSuite) SetUpTest(c *C) {
-	loggo.ResetLogging()
+	loggo.ResetLoggers()
 	loggo.RemoveWriter("default")
 	s.logger = loggo.GetLogger("test.writer")
 	// Make it so the logger itself writes all messages.
@@ -101,7 +101,7 @@
 }
 
 func (s *writerSuite) TearDownSuite(c *C) {
-	loggo.ResetLogging()
+	loggo.ResetLoggers()
 }
 
 func (s *writerSuite) TestWritingCapturesFileAndLineAndModule(c *C) {
@@ -109,7 +109,7 @@
 	err := loggo.RegisterWriter("test", writer, loggo.INFO)
 	c.Assert(err, IsNil)
 
-	s.logger.Info("Info message")
+	s.logger.Infof("Info message")
 
 	// WARNING: test checks the line number of the above logger lines, this
 	// will mean that if the above line moves, the test will fail unless
@@ -126,11 +126,11 @@
 	c.Assert(err, IsNil)
 
 	start := time.Now()
-	s.logger.Critical("Something critical.")
-	s.logger.Error("An error.")
-	s.logger.Warning("A warning message")
-	s.logger.Info("Info message")
-	s.logger.Trace("Trace the function")
+	s.logger.Criticalf("Something critical.")
+	s.logger.Errorf("An error.")
+	s.logger.Warningf("A warning message")
+	s.logger.Infof("Info message")
+	s.logger.Tracef("Trace the function")
 	end := time.Now()
 
 	c.Assert(writer.Log, HasLen, 3)
@@ -153,11 +153,11 @@
 	c.Assert(err, IsNil)
 
 	start := time.Now()
-	s.logger.Critical("Something critical.")
-	s.logger.Error("An error.")
-	s.logger.Warning("A warning message")
-	s.logger.Info("Info message")
-	s.logger.Trace("Trace the function")
+	s.logger.Criticalf("Something critical.")
+	s.logger.Errorf("An error.")
+	s.logger.Warningf("A warning message")
+	s.logger.Infof("Info message")
+	s.logger.Tracef("Trace the function")
 	end := time.Now()
 
 	c.Assert(writer.Log, HasLen, 5)
@@ -196,10 +196,10 @@
 	err = loggo.RegisterWriter("trace", traceWriter, loggo.TRACE)
 	c.Assert(err, IsNil)
 
-	s.logger.Error("An error.")
-	s.logger.Warning("A warning message")
-	s.logger.Info("Info message")
-	s.logger.Trace("Trace the function")
+	s.logger.Errorf("An error.")
+	s.logger.Warningf("A warning message")
+	s.logger.Infof("Info message")
+	s.logger.Tracef("Trace the function")
 
 	c.Assert(errorWriter.Log, HasLen, 1)
 	c.Assert(warningWriter.Log, HasLen, 2)