func (m *PyModule) Init(tag string, ctxObj py.Object) { var ctx log.Context if c, ok := ctxObj.(*PyContext); ok { ctx = c } else { ctx = log.NilContext } m.Module = log.New(tag, ctx).(*log.Module) }
func NewScheduler() _Scheduler { var s _Scheduler s.tasks = make(map[TaskHook]*list.List) for _, hook := range taskHookConstants { s.tasks[hook] = list.New() } s.logger = log.New("scheduler", log.NilContext) return s }
func TestDispatch(t *testing.T) { log.Targets = map[string]log.Handler{} log.Targets["target1"] = &mockTarget{make([]log.Record, 0)} log.Targets["target2"] = &mockTarget{make([]log.Record, 0)} logger := log.New("testing", log.MapContext{ "A": 123, }) entries := []entry{ entry{ log.LvlInfo, "Log Message 1", }, entry{ log.LvlDebug, "Log Message 2", }, } for _, r := range entries { logger.Dispatch(r.lvl, r.msg) } if len(log.Targets) != 2 { t.Error("Target length invalid") } for _, target := range log.Targets { records := target.(*mockTarget).records if len(records) != 2 { t.Error("Record length invalid") } for i, r := range records { if r.Level() != entries[i].lvl { t.Error("Log level mismatch") } if r.Tag() != "testing" { t.Error("Log tag mismatch") } if r.Message() != entries[i].msg { t.Error("Log message mismatch") } rctx := r.Context().ContextMap() if v, ok := rctx["A"]; !ok || v != 123 { t.Error("Log context mismatch") } } } }
func TestConvenienceFunctions(t *testing.T) { log.Targets = map[string]log.Handler{} log.Targets["target"] = &mockTarget{make([]log.Record, 0)} logger := log.New("testing", log.MapContext{ "A": 123, }) entries := []entry{ entry{ log.LvlInfo, "Log Message 1", }, entry{ log.LvlError, "Log Message 2", }, entry{ log.LvlDebug, "Log Message 3", }, } logger.Info(entries[0].msg) logger.Error(entries[1].msg) logger.Debug(entries[2].msg) target := log.Targets["target"] records := target.(*mockTarget).records if len(records) != 3 { t.Error("Record length invalid") } for i, r := range records { if r.Level() != entries[i].lvl { t.Error("Log level mismatch") } if r.Tag() != "testing" { t.Error("Log tag mismatch") } if r.Message() != entries[i].msg { t.Error("Log message mismatch") } rctx := r.Context().ContextMap() if v, ok := rctx["A"]; !ok || v != 123 { t.Error("Log context mismatch") } } }
package gem import ( "time" engine_event "github.com/gemrs/gem/gem/engine/event" "github.com/gemrs/gem/gem/task" "github.com/gemrs/gem/gem/util/safe" "github.com/gemrs/willow/log" "github.com/qur/gopy/lib" tomb "gopkg.in/tomb.v2" ) var logger = log.New("engine", log.NilContext) type Engine struct { py.BaseObject t tomb.Tomb } var EngineTick = 600 * time.Millisecond func (e *Engine) Init() {} func (e *Engine) Start() { logger.Info("Starting engine") engine_event.Startup.NotifyObservers() e.t.Go(e.run)
import ( "fmt" "net" "sync" "github.com/gemrs/gem/gem/protocol" "github.com/gemrs/gem/gem/util/id" "github.com/gemrs/gem/gem/util/safe" "github.com/gemrs/willow/log" "github.com/qur/gopy/lib" tomb "gopkg.in/tomb.v2" ) var logger = log.New("server", log.NilContext) // Server is the listener object and its associated state type Server struct { py.BaseObject laddr string ln net.Listener nextIndex <-chan int m sync.Mutex clients map[int]Client services map[int]Service t tomb.Tomb
func (s *Sector) Init(position *position.Sector) { s.Collection = entity.NewCollection() s.position = position s.logger = log.New("world/sector", log.MapContext{"position": position}) }
import ( "fmt" "net" "regexp" "sync" "github.com/gemrs/gem/gem/runite" "github.com/gemrs/gem/gem/runite/format/rt3" "github.com/gemrs/willow/log" "bufio" "github.com/qur/gopy/lib" tomb "gopkg.in/tomb.v2" ) var logger = log.New("archive", log.NilContext) var requestRegexp = regexp.MustCompile("JAGGRAB /([a-z]+)[0-9\\-]+") type Server struct { py.BaseObject laddr string ln net.Listener archives *rt3.ArchiveFS t tomb.Tomb } func (s *Server) Init() {}
func (e *Event) Init(key string) { e.key = key e.observers = make(map[int]Observer) e.log = log.New("event", log.MapContext{"event": key}) }
func TestBuffer(t *testing.T) { mtarget := &mockTarget{make([]log.Record, 0)} buffer := log.NewBufferingTarget(mtarget) log.Targets = map[string]log.Handler{} log.Targets["buffer"] = buffer logger := log.New("testing", log.MapContext{ "A": 123, }) entries := []entry{ entry{ log.LvlInfo, "Log Message 1", }, entry{ log.LvlDebug, "Log Message 2", }, } buffer.Redirect() logger.Dispatch(entries[0].lvl, entries[0].msg) if len(buffer.Buffered()) != 1 { t.Error("Buffered length incorrect") } if len(mtarget.records) != 0 { t.Error("Handled length incorrect") } buffer.Flush() if buffer.Buffered() != nil { t.Error("Buffer not emptied") } if len(mtarget.records) != 1 { t.Error("Buffer not flushed") } logger.Dispatch(entries[1].lvl, entries[1].msg) if len(mtarget.records) != 2 { t.Error("Buffer not flushed") } records := mtarget.records for i, r := range records { if r.Level() != entries[i].lvl { t.Error("Log level mismatch") } if r.Tag() != "testing" { t.Error("Log tag mismatch") } if r.Message() != entries[i].msg { t.Error("Log message mismatch") } rctx := r.Context().ContextMap() if v, ok := rctx["A"]; !ok || v != 123 { t.Error("Log context mismatch") } } }