func (*loggerSuite) TestModuleLowered(c *gc.C) {
logger1 := loggo.GetLogger("TESTING.MODULE")
logger2 := loggo.GetLogger("Testing")
c.Assert(logger1.Name(), gc.Equals, "testing.module")
c.Assert(logger2.Name(), gc.Equals, "testing")
}
func (*loggerSuite) TestLevelsSharedForSameModule(c *gc.C) {
logger1 := loggo.GetLogger("testing.module")
logger2 := loggo.GetLogger("testing.module")
logger1.SetLogLevel(loggo.INFO)
c.Assert(logger1.IsInfoEnabled(), gc.Equals, true)
c.Assert(logger2.IsInfoEnabled(), gc.Equals, true)
}
func (s *writerSuite) SetUpTest(c *gc.C) {
loggo.ResetLoggers()
loggo.RemoveWriter("default")
s.logger = loggo.GetLogger("test.writer")
// Make it so the logger itself writes all messages.
s.logger.SetLogLevel(loggo.TRACE)
}
func (s *logwriterSuite) SetUpTest(c *gc.C) {
loggo.ResetLoggers()
loggo.RemoveWriter("default")
s.writer = &loggo.TestWriter{}
err := loggo.RegisterWriter("test", s.writer, loggo.TRACE)
c.Assert(err, gc.IsNil)
s.logger = loggo.GetLogger("test.writer")
// Make it so the logger itself writes all messages.
s.logger.SetLogLevel(loggo.TRACE)
}
func (*loggerSuite) TestLevelsInherited(c *gc.C) {
root := loggo.GetLogger("")
first := loggo.GetLogger("first")
second := loggo.GetLogger("first.second")
root.SetLogLevel(loggo.ERROR)
c.Assert(root.LogLevel(), gc.Equals, loggo.ERROR)
c.Assert(root.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(first.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(first.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(second.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(second.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
first.SetLogLevel(loggo.DEBUG)
c.Assert(root.LogLevel(), gc.Equals, loggo.ERROR)
c.Assert(root.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(first.LogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(first.EffectiveLogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(second.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(second.EffectiveLogLevel(), gc.Equals, loggo.DEBUG)
second.SetLogLevel(loggo.INFO)
c.Assert(root.LogLevel(), gc.Equals, loggo.ERROR)
c.Assert(root.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(first.LogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(first.EffectiveLogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(second.LogLevel(), gc.Equals, loggo.INFO)
c.Assert(second.EffectiveLogLevel(), gc.Equals, loggo.INFO)
first.SetLogLevel(loggo.UNSPECIFIED)
c.Assert(root.LogLevel(), gc.Equals, loggo.ERROR)
c.Assert(root.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(first.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(first.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(second.LogLevel(), gc.Equals, loggo.INFO)
c.Assert(second.EffectiveLogLevel(), gc.Equals, loggo.INFO)
}
func TestSyslog(t *testing.T) {
for _, network := range []string{"tcp", "udp"} {
s := newTestServer(network)
connectTimeout := time.Duration(30) * time.Second
writeTimeout := connectTimeout
var log = loggo.GetLogger("")
logger, err := Dial(clienthost, network, s.Addr, nil, connectTimeout, writeTimeout, &log)
if err != nil {
t.Errorf("unexpected dial error %v", err)
}
packets := generatePackets()
for _, p := range packets {
logger.writePacket(p)
time.Sleep(100 * time.Millisecond)
}
s.Close <- true
for _, p := range packets {
expected := p.Generate(0)
if network == "tcp" {
expected = expected + "\n"
}
select {
case got := <-s.Messages:
if got != expected {
t.Errorf("expected %s, got %s", expected, got)
}
default:
t.Errorf("expected %s, got nothing", expected)
break
}
}
if l := len(s.Messages); l != 0 {
t.Errorf("found %d extra messages", l)
}
}
}
func initLogger() {
logger = loggo.GetLogger("confilter.server")
}
package main
import (
"github.com/howbazaar/loggo"
)
var first = loggo.GetLogger("first")
func FirstCritical(message string) {
first.Criticalf(message)
}
func FirstError(message string) {
first.Errorf(message)
}
func FirstWarning(message string) {
first.Warningf(message)
}
func FirstInfo(message string) {
first.Infof(message)
}
func FirstTrace(message string) {
first.Tracef(message)
}
package postgres_backend
import (
"database/sql"
"encoding/json"
"errors"
"github.com/howbazaar/loggo"
"github.com/lib/pq"
"github.com/straumur/straumur"
"time"
)
var (
logger = loggo.GetLogger("straumur.postgres")
)
// Callback for a managed transaction
//
// Example:
//
// err := p.wrapTransaction(func(tx *sql.Tx) error {
// rows, err := tx.Query(query, args...)
// if err != nil {
// return err
// }
// }
//
type TransactionFunc func(*sql.Tx) error
type PostgresDataSource struct {
pg *sql.DB
package main
import (
"github.com/howbazaar/loggo"
)
var second = loggo.GetLogger("second")
func SecondCritical(message string) {
second.Criticalf(message)
}
func SecondError(message string) {
second.Errorf(message)
}
func SecondWarning(message string) {
second.Warningf(message)
}
func SecondInfo(message string) {
second.Infof(message)
}
func SecondTrace(message string) {
second.Tracef(message)
}
package ws
import (
"code.google.com/p/go.net/websocket"
"github.com/howbazaar/loggo"
"github.com/straumur/straumur"
"net/http"
)
var (
logger = loggo.GetLogger("straumur.websocket")
)
type Server struct {
pattern string
events chan *straumur.Event
clients map[int]*Client
addCh chan *Client
delCh chan *Client
doneCh chan bool
errCh chan error
}
// Create a new Websocket broadcaster
func NewServer(pattern string) *Server {
clients := make(map[int]*Client)
addCh := make(chan *Client)
delCh := make(chan *Client)
doneCh := make(chan bool)
errCh := make(chan error)
"github.com/gorilla/sessions"
"github.com/howbazaar/loggo"
"github.com/nu7hatch/gouuid"
"github.com/straumur/straumur"
"io"
"net/http"
"strconv"
"time"
)
var (
ErrSaveExisting = errors.New("Save existing resource")
ErrUpdateNonExisting = errors.New("Update non-existing resource")
ErrMissingType = errors.New("Missing type param")
ErrInvalidEntity = errors.New("Invalid entity")
logger = loggo.GetLogger("straumur.rest")
sessionName = "straumur"
clientVarName = "client-id"
)
type RESTService struct {
Headers map[string]string
Store sessions.Store
databackend straumur.DataBackend
events chan *straumur.Event
WsServer *WebSocketServer
errchan chan error
}
// Returns the entity prefix
func getEntity(req *http.Request) (string, error) {
func (*loggerSuite) TestSetLevel(c *gc.C) {
logger := loggo.GetLogger("testing")
c.Assert(logger.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.WARNING)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, true)
c.Assert(logger.IsInfoEnabled(), gc.Equals, false)
c.Assert(logger.IsDebugEnabled(), gc.Equals, false)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
logger.SetLogLevel(loggo.TRACE)
c.Assert(logger.LogLevel(), gc.Equals, loggo.TRACE)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.TRACE)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, true)
c.Assert(logger.IsInfoEnabled(), gc.Equals, true)
c.Assert(logger.IsDebugEnabled(), gc.Equals, true)
c.Assert(logger.IsTraceEnabled(), gc.Equals, true)
logger.SetLogLevel(loggo.DEBUG)
c.Assert(logger.LogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.DEBUG)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, true)
c.Assert(logger.IsInfoEnabled(), gc.Equals, true)
c.Assert(logger.IsDebugEnabled(), gc.Equals, true)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
logger.SetLogLevel(loggo.INFO)
c.Assert(logger.LogLevel(), gc.Equals, loggo.INFO)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.INFO)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, true)
c.Assert(logger.IsInfoEnabled(), gc.Equals, true)
c.Assert(logger.IsDebugEnabled(), gc.Equals, false)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
logger.SetLogLevel(loggo.WARNING)
c.Assert(logger.LogLevel(), gc.Equals, loggo.WARNING)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.WARNING)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, true)
c.Assert(logger.IsInfoEnabled(), gc.Equals, false)
c.Assert(logger.IsDebugEnabled(), gc.Equals, false)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
logger.SetLogLevel(loggo.ERROR)
c.Assert(logger.LogLevel(), gc.Equals, loggo.ERROR)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.ERROR)
c.Assert(logger.IsErrorEnabled(), gc.Equals, true)
c.Assert(logger.IsWarningEnabled(), gc.Equals, false)
c.Assert(logger.IsInfoEnabled(), gc.Equals, false)
c.Assert(logger.IsDebugEnabled(), gc.Equals, false)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
// This is added for completeness, but not really expected to be used.
logger.SetLogLevel(loggo.CRITICAL)
c.Assert(logger.LogLevel(), gc.Equals, loggo.CRITICAL)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.CRITICAL)
c.Assert(logger.IsErrorEnabled(), gc.Equals, false)
c.Assert(logger.IsWarningEnabled(), gc.Equals, false)
c.Assert(logger.IsInfoEnabled(), gc.Equals, false)
c.Assert(logger.IsDebugEnabled(), gc.Equals, false)
c.Assert(logger.IsTraceEnabled(), gc.Equals, false)
logger.SetLogLevel(loggo.UNSPECIFIED)
c.Assert(logger.LogLevel(), gc.Equals, loggo.UNSPECIFIED)
c.Assert(logger.EffectiveLogLevel(), gc.Equals, loggo.WARNING)
}
func (*loggerSuite) TestModuleName(c *gc.C) {
logger := loggo.GetLogger("loggo.testing")
c.Assert(logger.Name(), gc.Equals, "loggo.testing")
}
package main
import (
"fmt"
"os"
"github.com/howbazaar/loggo"
)
var logger = loggo.GetLogger("main")
var rootLogger = loggo.GetLogger("")
func main() {
args := os.Args
if len(args) > 1 {
loggo.ConfigureLoggers(args[1])
} else {
fmt.Println("Add a parameter to configure the logging:")
fmt.Println("E.g. \"<root>=INFO;first=TRACE\"")
}
fmt.Println("\nCurrent logging levels:")
fmt.Println(loggo.LoggerInfo())
fmt.Println("")
rootLogger.Infof("Start of test.")
FirstCritical("first critical")
FirstError("first error")
FirstWarning("first warning")
FirstInfo("first info")
FirstTrace("first trace")
import (
"net"
"os"
"path"
"path/filepath"
"regexp"
"strconv"
"time"
"github.com/ActiveState/tail"
"github.com/howbazaar/loggo"
"github.com/papertrail/remote_syslog2/syslog"
"github.com/papertrail/remote_syslog2/utils"
)
var log = loggo.GetLogger("")
// Tails a single file
func tailOne(file string, excludePatterns []*regexp.Regexp, logger *syslog.Logger, wr *WorkerRegistry, severity syslog.Priority, facility syslog.Priority, poll bool) {
defer wr.Remove(file)
wr.Add(file)
tailConfig := tail.Config{ReOpen: true, Follow: true, MustExist: true, Poll: poll, Location: &tail.SeekInfo{0, os.SEEK_END}}
t, err := tail.TailFile(file, tailConfig)
if err != nil {
log.Errorf("%s", err)
return
}
for line := range t.Lines {
import (
"github.com/howbazaar/loggo"
)
type hub struct {
feeds []EventFeed
db DataBackend
broadcasters []Broadcaster
dataservices []DataService
Errs chan error
quit chan struct{}
processors map[string]*processorList
}
var (
logger = loggo.GetLogger("straumur.core")
)
func NewHub(d DataBackend) *hub {
return &hub{
db: d,
Errs: make(chan error),
quit: make(chan struct{}),
processors: make(map[string]*processorList),
}
}
func (h *hub) RegisterProcessor(step, pattern string, f Processor) error {
pl, ok := h.processors[step]
if !ok {
pl = NewProcessorList()
