Merge lp:~chipaca/snappy/different-logger into lp:~snappy-dev/snappy/snappy-moved-to-github

[John Lenton]

New, simpler logger.

Everything old is new again.

[lp:~chipaca/snappy/different-logger]

454. By John Lenton on 2015-05-08

clean up imports, typos

[John Lenton (chipaca)]

Just for the record:

perl -pi -w -e '$c=$ARGV;$c=~s|^(?:.*/)?cmd_(\w+?)(?:_test)?\.go$|$1|; s/logger\.LogAndPanic\(err\)/log.Panic("unable to $c: %v", err)/; s|snappy/logger|snappy/log|' cmd/snappy/cmd_*.go

[John Lenton (chipaca)]

(and for the record, it is my opinion that if a command is not a verb, and thus fits “unable to $verb”, it's a bug :) )

[Sergio Schvezov (sergiusens)]

Nice and simple, I think we can drop the loggo dep from debian/control as well now, right?

[John Lenton (chipaca)]

Correct! Will do that now.

[lp:~chipaca/snappy/different-logger]

455. By John Lenton on 2015-05-08

nuke loggo dependencies

456. By John Lenton on 2015-05-11

make vet and lint happy

[Sergio Schvezov (sergiusens)]

review: Approve

=== modified file 'cmd/snappy/cmd_booted.go'
--- cmd/snappy/cmd_booted.go	2015-05-11 15:56:13 +0000
+++ cmd/snappy/cmd_booted.go	2015-05-11 15:56:13 +0000
@@ -32,7 +32,7 @@
 		"internal",
 		&cmdBooted{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to booted: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_build.go'
--- cmd/snappy/cmd_build.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_build.go	2015-05-11 15:56:13 +0000
@@ -38,7 +38,7 @@
 		longBuildHelp,
 		&cmdBuild{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to build: %v", err)
 	}
 
 	cmd.Aliases = append(cmd.Aliases, "bu")

=== modified file 'cmd/snappy/cmd_config.go'
--- cmd/snappy/cmd_config.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_config.go	2015-05-11 15:56:13 +0000
@@ -44,7 +44,7 @@
 		longConfigHelp,
 		&cmdConfig{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to config: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_first_boot.go'
--- cmd/snappy/cmd_first_boot.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_first_boot.go	2015-05-11 15:56:13 +0000
@@ -32,7 +32,7 @@
 		"internal",
 		&cmdInternalFirstBootOemConfig{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to first_boot: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_hwassign.go'
--- cmd/snappy/cmd_hwassign.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_hwassign.go	2015-05-11 15:56:13 +0000
@@ -42,7 +42,7 @@
 		longHWAssignHelp,
 		&cmdHWAssign{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to hwassign: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_hwinfo.go'
--- cmd/snappy/cmd_hwinfo.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_hwinfo.go	2015-05-11 15:56:13 +0000
@@ -42,7 +42,7 @@
 		longHWInfoHelp,
 		&cmdHWInfo{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to hwinfo: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_hwunassign.go'
--- cmd/snappy/cmd_hwunassign.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_hwunassign.go	2015-05-11 15:56:13 +0000
@@ -42,7 +42,7 @@
 		longHWUnassignHelp,
 		&cmdHWUnassign{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to hwunassign: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_info.go'
--- cmd/snappy/cmd_info.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_info.go	2015-05-11 15:56:13 +0000
@@ -48,7 +48,7 @@
 		longInfoHelp,
 		&cmdInfo{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to info: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_install.go'
--- cmd/snappy/cmd_install.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_install.go	2015-05-11 15:56:13 +0000
@@ -43,7 +43,7 @@
 		"Install a snap package",
 		&cmdInstall{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to install: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_internal_run_hooks.go'
--- cmd/snappy/cmd_internal_run_hooks.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_internal_run_hooks.go	2015-05-11 15:56:13 +0000
@@ -14,7 +14,7 @@
 		"internal",
 		&cmdInternalRunHooks{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to internal_run_hooks: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_internal_unpack.go'
--- cmd/snappy/cmd_internal_unpack.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_internal_unpack.go	2015-05-11 15:56:13 +0000
@@ -151,7 +151,7 @@
 		"internal",
 		&cmdInternalUnpack{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to internal_unpack: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_list.go'
--- cmd/snappy/cmd_list.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_list.go	2015-05-11 15:56:13 +0000
@@ -49,7 +49,7 @@
 		longListHelp,
 		&cmdList{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to list: %v", err)
 	}
 
 	cmd.Aliases = append(cmd.Aliases, "li")

=== modified file 'cmd/snappy/cmd_login.go'
--- cmd/snappy/cmd_login.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_login.go	2015-05-11 15:56:13 +0000
@@ -44,7 +44,7 @@
 		longLoginHelp,
 		&cmdLogin{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to login: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_purge.go'
--- cmd/snappy/cmd_purge.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_purge.go	2015-05-11 15:56:13 +0000
@@ -41,7 +41,7 @@
 		longPurgeHelp,
 		&cmdPurge{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to purge: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_remove.go'
--- cmd/snappy/cmd_remove.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_remove.go	2015-05-11 15:56:13 +0000
@@ -36,7 +36,7 @@
 		"Remove a snapp part",
 		&cmdRemove{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to remove: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_rollback.go'
--- cmd/snappy/cmd_rollback.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_rollback.go	2015-05-11 15:56:13 +0000
@@ -44,7 +44,7 @@
 		longRollbackHelp,
 		&cmdRollback{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to rollback: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_search.go'
--- cmd/snappy/cmd_search.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_search.go	2015-05-11 15:56:13 +0000
@@ -36,7 +36,7 @@
 		"Query the store for available packages",
 		&cmdSearch{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to search: %v", err)
 	}
 
 	cmd.Aliases = append(cmd.Aliases, "se")

=== modified file 'cmd/snappy/cmd_set.go'
--- cmd/snappy/cmd_set.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_set.go	2015-05-11 15:56:13 +0000
@@ -44,7 +44,7 @@
 		setHelp,
 		&cmdSet{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to set: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_update.go'
--- cmd/snappy/cmd_update.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_update.go	2015-05-11 15:56:13 +0000
@@ -40,7 +40,7 @@
 		"Ensures system is running with latest parts",
 		&cmdUpdate{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to update: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/cmd_versions.go'
--- cmd/snappy/cmd_versions.go	2015-05-08 13:41:11 +0000
+++ cmd/snappy/cmd_versions.go	2015-05-11 15:56:13 +0000
@@ -36,7 +36,7 @@
 		longVersionsHelp,
 		&cmdVersions{})
 	if err != nil {
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to versions: %v", err)
 	}
 }
 

=== modified file 'cmd/snappy/main.go'
--- cmd/snappy/main.go	2015-03-26 13:02:07 +0000
+++ cmd/snappy/main.go	2015-05-11 15:56:13 +0000
@@ -42,7 +42,7 @@
 var parser = flags.NewParser(&optionsData, flags.Default)
 
 func init() {
-	err := logger.ActivateLogger()
+	err := logger.SimpleSetup()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "WARNING: failed to activate logging: %s\n", err)
 	}

=== modified file 'debian/control'
--- debian/control	2015-04-21 22:02:02 +0000
+++ debian/control	2015-05-11 15:56:13 +0000
@@ -13,7 +13,6 @@
                golang-go.crypto-dev,
                golang-gocheck-dev,
                golang-goconfigparser-dev,
-               golang-juju-loggo-dev,
                golang-pb-dev,
                golang-yaml.v2-dev
 Standards-Version: 3.9.6

=== modified file 'dependencies.tsv'
--- dependencies.tsv	2015-03-19 09:33:48 +0000
+++ dependencies.tsv	2015-05-11 15:56:13 +0000
@@ -2,7 +2,6 @@
 github.com/blakesmith/ar	git	c9a977dd0cc1392b023382c7bfa5a22af8d3b730	2013-02-19T04:59:55Z
 github.com/cheggaaa/pb	git	e8c7cc515bfde3e267957a3b110080ceed51354e	2014-12-02T07:01:21Z
 github.com/jessevdk/go-flags	git	15347ef417a300349807983f15af9e65cd2e1b3a	2015-01-25T08:53:51Z
-github.com/juju/loggo	git	4c7cbce140ca070eeb59a28f4bf9507e511711f9	2015-02-26T05:51:10Z
 github.com/mvo5/goconfigparser	git	26426272dda20cc76aa1fa44286dc743d2972fe8	2015-02-12T09:37:50Z
 gopkg.in/yaml.v2	git	49c95bdc21843256fb6c4e0d370a05f24a0bf213	2015-02-24T22:57:58Z
 launchpad.net/gocheck	bzr	[e-mail]-20140225173054-xu9zlkf9kxhvow02	87

=== added directory 'logger'
=== removed directory 'logger'
=== added file 'logger/logger.go'
--- logger/logger.go	1970-01-01 00:00:00 +0000
+++ logger/logger.go	2015-05-11 15:56:13 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package logger
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"log/syslog"
+	"os"
+	"sync"
+)
+
+// A Logger is a fairly minimal logging tool.
+type Logger interface {
+	// Notice is for messages that the user should see
+	Notice(msg string)
+	// Debug is for messages that the user should be able to find if they're debugging something
+	Debug(msg string)
+}
+
+const (
+	// DefaultFlags are passed to the default console log.Logger
+	DefaultFlags = log.Ldate | log.Ltime | log.Lmicroseconds | log.Lshortfile
+	// SyslogFlags are passed to the default syslog log.Logger
+	SyslogFlags = log.Lshortfile
+	// SyslogPriority for the default syslog log.Logger
+	SyslogPriority = syslog.LOG_DEBUG | syslog.LOG_USER
+)
+
+type nullLogger struct{}
+
+func (nullLogger) Notice(string) {}
+func (nullLogger) Debug(string)  {}
+
+// NullLogger is a logger that does nothing
+var NullLogger = nullLogger{}
+
+var (
+	logger Logger = NullLogger
+	lock   sync.Mutex
+)
+
+// Panicf notifies the user and then panics
+func Panicf(format string, v ...interface{}) {
+	msg := fmt.Sprintf(format, v...)
+
+	lock.Lock()
+	defer lock.Unlock()
+
+	logger.Notice("PANIC " + msg)
+	panic(msg)
+}
+
+// Noticef notifies the user of something
+func Noticef(format string, v ...interface{}) {
+	msg := fmt.Sprintf(format, v...)
+
+	lock.Lock()
+	defer lock.Unlock()
+
+	logger.Notice(msg)
+}
+
+// Debugf records something in the debug log
+func Debugf(format string, v ...interface{}) {
+	msg := fmt.Sprintf(format, v...)
+
+	lock.Lock()
+	defer lock.Unlock()
+
+	logger.Debug(msg)
+}
+
+// SetLogger sets the global logger to the given one
+func SetLogger(l Logger) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	logger = l
+}
+
+// ConsoleLog sends Notices to a log.Logger and Debugs to syslog
+type ConsoleLog struct {
+	log *log.Logger
+	sys *log.Logger
+}
+
+// Debug sends the msg to syslog
+func (l *ConsoleLog) Debug(msg string) {
+	l.sys.Output(3, "DEBUG: "+msg)
+}
+
+// Notice alerts the user about something, as well as putting it syslog
+func (l *ConsoleLog) Notice(msg string) {
+	l.sys.Output(3, msg)
+	l.log.Output(3, msg)
+}
+
+// NewConsoleLog creates a ConsoleLog with a log.Logger using the given
+// io.Writer and flag, and a syslog.Writer.
+func NewConsoleLog(w io.Writer, flag int) (*ConsoleLog, error) {
+	sys, err := syslog.NewLogger(SyslogPriority, SyslogFlags)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ConsoleLog{
+		log: log.New(w, "", flag),
+		sys: sys,
+	}, nil
+}
+
+// SimpleSetup creates the default (console) logger
+func SimpleSetup() error {
+	l, err := NewConsoleLog(os.Stderr, DefaultFlags)
+	if err != nil {
+		return err
+	}
+	SetLogger(l)
+
+	return nil
+}

=== removed file 'logger/logger.go'
--- logger/logger.go	2015-05-11 15:56:13 +0000
+++ logger/logger.go	1970-01-01 00:00:00 +0000
@@ -1,189 +0,0 @@
-/*
- * Copyright (C) 2014-2015 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-package logger
-
-import (
-	"fmt"
-	"log/syslog"
-	"runtime/debug"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/juju/loggo"
-)
-
-// Name used in the prefix for all logged messages
-const LoggerName = "snappy"
-
-// logWriterInterface allows the tests to replace the syslog
-// implementation.
-type logWriterInterface interface {
-	// syslog.Writer
-	Debug(m string) error
-	Info(m string) error
-	Warning(m string) error
-	Err(m string) error
-	Crit(m string) error
-}
-
-// LogWriter object that handles writing log entries
-type LogWriter struct {
-	systemLog logWriterInterface
-}
-
-// Used to ensure that only a single connection to syslog is created
-var once sync.Once
-
-// A single connection to the system logger
-var syslogConnection logWriterInterface
-
-// Write sends the log details specified by the params to the logging
-// back-end (in this case syslog).
-func (l *LogWriter) Write(level loggo.Level, name string, filename string, line int, timestamp time.Time, message string) {
-	var f func(string) error
-
-	record := l.Format(level, name, filename, line, timestamp, message)
-
-	// map log level to syslog priority
-	switch level {
-	case loggo.DEBUG:
-		f = l.systemLog.Debug
-
-	case loggo.INFO:
-		f = l.systemLog.Info
-
-	case loggo.WARNING:
-		f = l.systemLog.Warning
-
-	case loggo.ERROR:
-		f = l.systemLog.Err
-
-	case loggo.CRITICAL:
-		f = l.systemLog.Crit
-	}
-
-	// write the log record.
-	//
-	// Note that with loggo, the actual logging functions never
-	// return errors, so although these syslog functions may fail,
-	// there's not much we can do about it.
-	f(record)
-
-	if level >= loggo.ERROR {
-		l.logStacktrace(level, name, filename, line, timestamp, f)
-	}
-}
-
-func (l *LogWriter) logStacktrace(level loggo.Level, name string, filename string, line int, timestamp time.Time, f func(string) error) {
-	stack := debug.Stack()
-
-	str := "Stack trace:"
-	record := l.Format(level, name, filename, line, timestamp, str)
-	f(record)
-
-	for _, entry := range strings.Split(string(stack), "\n") {
-		if entry == "" {
-			continue
-		}
-
-		formatted := fmt.Sprintf("  %s", strings.Replace(entry, "\t", "  ", -1))
-		record := l.Format(level, name, filename, line, timestamp, formatted)
-		f(record)
-	}
-}
-
-// Format handles how each log entry should appear.
-// Note that the timestamp field is not used as syslog adds that for us.
-func (l *LogWriter) Format(level loggo.Level, module, filename string, line int, timestamp time.Time, message string) string {
-	if level < loggo.ERROR {
-		// keep it relatively succinct for low priority messages
-		return fmt.Sprintf("%s:%s:%s", level, module, message)
-	}
-
-	return fmt.Sprintf("%s:%s:%s:%d:%s", level, module, filename, line, message)
-}
-
-// A variable to make testing easier
-var getSyslog = func(priority syslog.Priority, tag string) (w logWriterInterface, err error) {
-	return syslog.New(syslog.LOG_NOTICE|syslog.LOG_LOCAL0, LoggerName)
-}
-
-// newLogWriter creates a new LogWriter, ensuring that only a single
-// connection to the system logger is created.
-func newLogWriter() (l *LogWriter, err error) {
-
-	l = new(LogWriter)
-
-	once.Do(func() {
-
-		// Note that the log level here is just the default - Write()
-		// will alter it as needed.
-		syslogConnection, err = getSyslog(syslog.LOG_NOTICE|syslog.LOG_LOCAL0, LoggerName)
-	})
-
-	if err != nil {
-		return nil, err
-	}
-
-	l.systemLog = syslogConnection
-
-	return l, nil
-}
-
-// ActivateLogger handles creating, configuring and enabling a new syslog logger.
-func ActivateLogger() (err error) {
-	// Remove any existing loggers of the type we care about.
-	//
-	// No check on the success of these operations is performed since the
-	// loggo API does not allow the existing loggers to be iterated so we
-	// cannot know if there is already a syslog writer registered (for
-	// example if newLogWriter() gets called multiple times).
-	_, _, _ = loggo.RemoveWriter("default")
-	_, _, _ = loggo.RemoveWriter("syslog")
-
-	writer, err := newLogWriter()
-	if err != nil {
-		return err
-	}
-
-	// activate our syslog logger
-	err = loggo.RegisterWriter("syslog", writer, loggo.TRACE)
-	if err != nil {
-		return err
-	}
-
-	logger := loggo.GetLogger(LoggerName)
-
-	// ensure that all log messages are output
-	logger.SetLogLevel(loggo.TRACE)
-
-	return nil
-}
-
-// LogAndPanic logs the specified error, including a backtrace, then calls
-// panic().
-func LogAndPanic(err error) {
-	if err == nil {
-		return
-	}
-
-	logger := loggo.GetLogger(LoggerName)
-	logger.Criticalf(err.Error())
-	panic(err)
-}

=== added file 'logger/logger_test.go'
--- logger/logger_test.go	1970-01-01 00:00:00 +0000
+++ logger/logger_test.go	2015-05-11 15:56:13 +0000
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package logger
+
+import (
+	"bytes"
+	"log"
+	"testing"
+
+	. "launchpad.net/gocheck"
+)
+
+// Hook up gocheck into the "go test" runner
+func Test(t *testing.T) { TestingT(t) }
+
+var _ = Suite(&LogSuite{})
+
+type LogSuite struct{}
+
+func (s *LogSuite) SetUpTest(c *C) {
+	c.Assert(logger, Equals, NullLogger)
+}
+
+func (s *LogSuite) TearDownTest(c *C) {
+	SetLogger(NullLogger)
+}
+
+func (s *LogSuite) TestDefault(c *C) {
+	if logger != nil {
+		SetLogger(nil)
+	}
+	c.Check(logger, IsNil)
+
+	err := SimpleSetup()
+	c.Check(err, IsNil)
+	c.Check(logger, NotNil)
+	SetLogger(nil)
+}
+
+func (s *LogSuite) TestNew(c *C) {
+	var buf bytes.Buffer
+	l, err := NewConsoleLog(&buf, DefaultFlags)
+	c.Assert(err, IsNil)
+	c.Assert(l, NotNil)
+	c.Check(l.sys, NotNil)
+	c.Check(l.log, NotNil)
+}
+
+func (s *LogSuite) TestDebugf(c *C) {
+	var logbuf bytes.Buffer
+	var sysbuf bytes.Buffer
+	l, err := NewConsoleLog(&logbuf, DefaultFlags)
+	c.Assert(err, IsNil)
+
+	l.sys = log.New(&sysbuf, "", SyslogFlags)
+	SetLogger(l)
+
+	Debugf("xyzzy")
+	c.Check(sysbuf.String(), Matches, `(?m).*logger_test\.go:\d+: DEBUG: xyzzy`)
+	c.Check(logbuf.String(), Equals, "")
+}
+
+func (s *LogSuite) TestNoticef(c *C) {
+	var logbuf bytes.Buffer
+	var sysbuf bytes.Buffer
+	l, err := NewConsoleLog(&logbuf, DefaultFlags)
+	c.Assert(err, IsNil)
+
+	l.sys = log.New(&sysbuf, "", SyslogFlags)
+	SetLogger(l)
+
+	Noticef("xyzzy")
+	c.Check(sysbuf.String(), Matches, `(?m).*logger_test\.go:\d+: xyzzy`)
+	c.Check(logbuf.String(), Matches, `(?m).*logger_test\.go:\d+: xyzzy`)
+}
+
+func (s *LogSuite) TestPanicf(c *C) {
+	var logbuf bytes.Buffer
+	var sysbuf bytes.Buffer
+	l, err := NewConsoleLog(&logbuf, DefaultFlags)
+	c.Assert(err, IsNil)
+
+	l.sys = log.New(&sysbuf, "", SyslogFlags)
+	SetLogger(l)
+
+	c.Check(func() { Panicf("xyzzy") }, Panics, "xyzzy")
+	c.Check(sysbuf.String(), Matches, `(?m).*logger_test\.go:\d+: PANIC xyzzy`)
+	c.Check(logbuf.String(), Matches, `(?m).*logger_test\.go:\d+: PANIC xyzzy`)
+}

=== removed file 'logger/logger_test.go'
--- logger/logger_test.go	2015-05-11 15:56:13 +0000
+++ logger/logger_test.go	1970-01-01 00:00:00 +0000
@@ -1,310 +0,0 @@
-/*
- * Copyright (C) 2014-2015 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-package logger
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"log/syslog"
-	"regexp"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/juju/loggo"
-	. "launchpad.net/gocheck"
-)
-
-func Test(t *testing.T) { TestingT(t) }
-
-type LoggerTestSuite struct {
-}
-
-var _ = Suite(&LoggerTestSuite{})
-
-type MockLogWriter struct {
-	buf bytes.Buffer
-}
-
-var mockWriter *MockLogWriter
-
-var loggoLevels = []string{"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
-
-func mockGetSyslog(priority syslog.Priority, tag string) (w logWriterInterface, err error) {
-	mockWriter = &MockLogWriter{}
-	return mockWriter, nil
-}
-
-func readLines() (lines []string) {
-	lines = strings.Split(string(mockWriter.buf.Bytes()), "\n")
-
-	// remove the last line if empty due to split.
-	length := len(lines)
-	last := lines[length-1]
-	if last == "" {
-		lines = lines[:length-1]
-	}
-	// clear the buffer to avoid contents accumulating indefinitely
-	mockWriter.buf.Reset()
-	return lines
-}
-
-func (ts *LoggerTestSuite) SetUpTest(c *C) {
-	getSyslog = mockGetSyslog
-}
-
-func (w *MockLogWriter) Debug(m string) error {
-	_, err := w.buf.Write([]byte(fmt.Sprintf("DEBUG: %s\n", m)))
-	return err
-}
-
-func (w *MockLogWriter) Info(m string) error {
-	_, err := w.buf.Write([]byte(fmt.Sprintf("INFO: %s\n", m)))
-	return err
-}
-
-func (w *MockLogWriter) Warning(m string) error {
-	_, err := w.buf.Write([]byte(fmt.Sprintf("WARNING: %s\n", m)))
-	return err
-}
-
-func (w *MockLogWriter) Err(m string) error {
-	_, err := w.buf.Write([]byte(fmt.Sprintf("ERROR: %s\n", m)))
-	return err
-}
-
-func (w *MockLogWriter) Crit(m string) error {
-	_, err := w.buf.Write([]byte(fmt.Sprintf("CRITICAL: %s\n", m)))
-	return err
-}
-
-// Search for value in array and return true if found
-func sliceContainsString(array []string, value string) bool {
-	str := string(strings.Join(array, ""))
-
-	return strings.Contains(str, value)
-}
-
-// Return true if array contains the pattern regex.
-func sliceContainsRegex(array []string, regex string) bool {
-	str := string(strings.Join(array, ""))
-
-	pattern := regexp.MustCompile(regex)
-
-	matches := pattern.FindAllStringSubmatch(str, -1)
-
-	return matches != nil
-}
-
-func (ts *LoggerTestSuite) TestNewLogWriter(c *C) {
-	var w, w2 *LogWriter
-	var err error
-
-	w, err = newLogWriter()
-	c.Assert(err, IsNil)
-	c.Assert(w, Not(IsNil))
-	c.Assert(w.systemLog, Not(IsNil))
-
-	w2, err = newLogWriter()
-	c.Assert(err, IsNil)
-	c.Assert(w2, Not(IsNil))
-	c.Assert(w2.systemLog, Not(IsNil))
-
-	// There should be a single shared syslog connection, hence the
-	// systemLog objects should be identical.
-	c.Assert(w.systemLog, Equals, w2.systemLog)
-	c.Assert(w.systemLog, DeepEquals, w2.systemLog)
-}
-
-func (ts *LoggerTestSuite) TestWrite(c *C) {
-	w, err := newLogWriter()
-	c.Assert(err, IsNil)
-	c.Assert(w, Not(IsNil))
-	c.Assert(w.systemLog, Not(IsNil))
-
-	t := time.Now()
-	strTime := fmt.Sprintf("%s", t)
-
-	for _, l := range loggoLevels {
-		level := stringToLogLevel(l)
-
-		w.Write(level, "module", "filename", 1234, t, "a message")
-		lines := readLines()
-
-		if level < loggo.ERROR {
-			c.Assert(len(lines), Equals, 1)
-		} else {
-			c.Assert(len(lines) > 1, Equals, true)
-
-			c.Assert(sliceContainsString(lines, "filename"), Equals, true)
-			c.Assert(sliceContainsString(lines, "1234"), Equals, true)
-		}
-
-		c.Assert(sliceContainsString(lines, "module"), Equals, true)
-
-		// We discard the timestamp as syslog adds that itself
-		c.Assert(sliceContainsString(lines, strTime), Equals, false)
-
-		c.Assert(sliceContainsString(lines, "a message"), Equals, true)
-	}
-
-}
-
-// Convert a loggo log level string representation into a real log
-// level.
-func stringToLogLevel(name string) loggo.Level {
-	level, ok := loggo.ParseLevel(name)
-
-	if !ok {
-		panic(fmt.Sprintf("unknown loggo level string: %q", name))
-	}
-
-	return level
-}
-
-func (ts *LoggerTestSuite) TestFormat(c *C) {
-	w, err := newLogWriter()
-	c.Assert(err, IsNil)
-	c.Assert(w, Not(IsNil))
-	c.Assert(w.systemLog, Not(IsNil))
-
-	for _, l := range loggoLevels {
-		level := stringToLogLevel(l)
-
-		if level < loggo.ERROR {
-			out := w.Format(level, "module", "filename", 1234, time.Now(), "a message")
-			c.Assert(out, Equals, fmt.Sprintf("%s:%s:%s", l, "module", "a message"))
-		} else {
-			out := w.Format(level, "module", "filename", 1234, time.Now(), "a message")
-			c.Assert(out, Equals, fmt.Sprintf("%s:%s:%s:%d:%s", l, "module", "filename", 1234, "a message"))
-		}
-	}
-}
-
-func (ts *LoggerTestSuite) TestLogStackTrace(c *C) {
-	var output []string
-
-	w, err := newLogWriter()
-	c.Assert(err, IsNil)
-	c.Assert(w, Not(IsNil))
-
-	f := func(s string) error {
-		output = append(output, s)
-		return nil
-	}
-
-	t := time.Now()
-	strTime := fmt.Sprintf("%s", t)
-
-	w.logStacktrace(loggo.DEBUG, "name", "filename", 9876, t, f)
-
-	c.Assert(sliceContainsString(output, "Stack trace"), Equals, true)
-	c.Assert(sliceContainsString(output, "name"), Equals, true)
-	c.Assert(sliceContainsString(output, "filename"), Equals, true)
-	c.Assert(sliceContainsString(output, "9876"), Equals, true)
-
-	// We discard the timestamp as syslog adds that itself
-	c.Assert(sliceContainsString(output, strTime), Equals, false)
-}
-
-func (ts *LoggerTestSuite) checkLogLevel(c *C, level, msg string) {
-	err := ActivateLogger()
-	c.Assert(err, IsNil)
-
-	expectBacktrace := (level == "ERROR" || level == "CRITICAL")
-
-	logger := loggo.GetLogger("snappy")
-	c.Assert(logger, Not(IsNil))
-
-	switch level {
-	case "DEBUG":
-		c.Assert(logger.IsDebugEnabled(), Equals, true)
-		logger.Debugf(msg)
-
-	case "INFO":
-		c.Assert(logger.IsInfoEnabled(), Equals, true)
-		logger.Infof(msg)
-
-	case "WARNING":
-		c.Assert(logger.IsWarningEnabled(), Equals, true)
-		logger.Warningf(msg)
-
-	case "ERROR":
-		c.Assert(logger.IsErrorEnabled(), Equals, true)
-		logger.Errorf(msg)
-
-	case "CRITICAL":
-		// loggo doesn't provide a IsCriticalEnabled()
-		c.Assert(logger.IsErrorEnabled(), Equals, true)
-		logger.Criticalf(msg)
-	}
-
-	lines := readLines()
-
-	if expectBacktrace {
-		c.Assert(len(lines) > 1, Equals, true)
-	} else {
-		c.Assert(len(lines), Equals, 1)
-	}
-
-	needle := fmt.Sprintf("%s.*%s", level, msg)
-	c.Assert(sliceContainsRegex(lines, needle), Equals, true)
-
-	c.Assert(sliceContainsString(lines, "Stack trace"), Equals, expectBacktrace)
-}
-
-func (ts *LoggerTestSuite) TestLogLevels(c *C) {
-	msg := "an error message"
-
-	for _, level := range loggoLevels {
-		ts.checkLogLevel(c, level, msg)
-	}
-}
-
-func (ts *LoggerTestSuite) TestLogAndPanic(c *C) {
-	level := "CRITICAL"
-	msg := "I am a fatal error"
-
-	panicked := false
-
-	err := ActivateLogger()
-	c.Assert(err, IsNil)
-
-	// If the specified error is nil, no panic is expected and no
-	// log entry should be added.
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				panicked = true
-			}
-		}()
-		LogAndPanic(nil)
-	}()
-
-	c.Assert(panicked, Equals, false)
-	c.Assert(len(readLines()), Equals, 0)
-
-	err = errors.New(msg)
-
-	// expect a panic...
-	c.Assert(func() { LogAndPanic(err) }, Panics, err)
-
-	// ... and a log entry
-	ts.checkLogLevel(c, level, msg)
-}

=== modified file 'snappy/dbus.go'
--- snappy/dbus.go	2015-04-19 01:24:03 +0000
+++ snappy/dbus.go	2015-05-11 15:56:13 +0000
@@ -75,7 +75,7 @@
 	}
 	if err := t.Execute(&templateOut, wrapperData); err != nil {
 		// this can never happen, except we forget a variable
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to execute template: %v", err)
 	}
 
 	return templateOut.String(), nil

=== modified file 'systemd/systemd.go'
--- systemd/systemd.go	2015-04-22 21:13:25 +0000
+++ systemd/systemd.go	2015-05-11 15:56:13 +0000
@@ -216,7 +216,7 @@
 	}
 	if err := t.Execute(&templateOut, wrapperData); err != nil {
 		// this can never happen, except we forget a variable
-		logger.LogAndPanic(err)
+		logger.Panicf("unable to execute template: %v", err)
 	}
 
 	return templateOut.String()