// TODO(riannucci): prefix with caller's code location.
func (gl *loggerImpl) LogCall(l logging.Level, calldepth int, format string, args []interface{}) {
if gl.aeCtx == nil || !logging.IsLogging(gl.ic, l) {
return
}
var logf func(context.Context, string, ...interface{})
switch l {
case logging.Debug:
logf = log.Debugf
case logging.Info:
logf = log.Infof
case logging.Warning:
logf = log.Warningf
case logging.Error:
fallthrough
default:
logf = log.Errorf
}
fields := logging.GetFields(gl.ic)
if len(fields) > 0 {
logf(gl.aeCtx, "%s :: %s", fmt.Sprintf(format, args...), fields.String())
} else {
logf(gl.aeCtx, format, args...)
}
}
// Use adds a memory backed Logger to Context, with concrete type
// *MemLogger. Casting to the concrete type can be used to inspect the
// log output after running a test case, for example.
func Use(c context.Context) context.Context {
lock := sync.Mutex{}
data := []LogEntry{}
return logging.SetFactory(c, func(ic context.Context) logging.Logger {
return &MemLogger{&lock, &data, logging.GetFields(ic)}
})
}
func (li *loggerImpl) LogCall(l logging.Level, calldepth int, format string, args []interface{}) {
// Append the fields to the format string.
if li.c != nil {
if !logging.IsLogging(li.c, l) {
return
}
if fields := logging.GetFields(li.c); len(fields) > 0 {
format = formatWithFields(format, fields, args)
args = nil
}
}
li.Lock()
defer li.Unlock()
li.l.ExtraCalldepth = (calldepth + 1)
switch l {
case logging.Debug:
li.l.Debug(format, args...)
case logging.Info:
li.l.Info(format, args...)
case logging.Warning:
li.l.Warning(format, args...)
case logging.Error:
li.l.Error(format, args...)
}
}
func (l *boundCloudLogger) LogCall(level log.Level, calldepth int, f string, args []interface{}) {
if len(f) == 0 || !log.IsLogging(l.ctx, level) {
return
}
l.logger.logC <- &logEntry{
timestamp: clock.Now(l.ctx),
level: level,
fmt: f,
args: args,
fields: log.GetFields(l.ctx),
}
}
func (g *gaeLoggerImpl) og(l logging.Level, logf func(string, ...interface{}),
format string, args []interface{}) {
if g.c != nil {
if !logging.IsLogging(g.c, l) {
return
}
}
fields := logging.GetFields(g.c)
if len(fields) > 0 {
logf("%s ctx%s", fmt.Sprintf(format, args...), fields.FieldString(true))
} else {
logf(format, args...)
}
}
func (l *boundCloudLogger) LogCall(level logging.Level, calldepth int, f string, args []interface{}) {
if len(f) == 0 {
return
}
text := fmt.Sprintf(f, args...)
fields := logging.GetFields(l.ctx)
if len(fields) > 0 {
text = text + " " + fields.FieldString(true)
}
// Add logging fields to labels.
entry := cloudlogging.Entry{
Timestamp: clock.Now(l.ctx),
Severity: l.getSeverity(level),
Labels: make(map[string]string, len(fields)),
TextPayload: text,
}
// Populate Labels.
for k, v := range fields {
val := ""
if l.FieldConverter != nil {
val = l.FieldConverter(v)
} else {
val = fmt.Sprintf("%v", v)
}
entry.Labels[k] = val
}
// Generate an InsertID, if we're configured with a base.
if l.InsertIDBase != "" {
entry.InsertID = l.generateInsertID()
}
l.client.PushEntries([]*cloudlogging.Entry{&entry})
}