// See: http://duktape.org/api.html#duk_log
430280
func (d *Context) Log(loglevel int, format string, value interface{}) {
	__str__ := C.CString(fmt.Sprintf(format, value))
	C._duk_log(d.duk_context, C.duk_int_t(loglevel), __str__)
	C.free(unsafe.Pointer(__str__))
}
755395
func (n *panicLogger) Log(keyvals ...interface{}) {
	r := keyvals
	if n.err != nil {
		r = append(r[0:len(r):len(r)], n.err)
	}
	buf := &bytes.Buffer{}
	f := LogfmtLogger{
		Out:             buf,
		MissingValueKey: Msg,
	}
	if err := f.Log(r...); err != nil {
		panic(r)
	}
	panic(buf.String())
}
69476
func (l *logger) Log(level Level, msg string, pairs ...interface{}) {
	if level <= l.Level {
		m := l.message(pairs...)
		l.Println(msg, m)
	}
}
1147062
func (s *Session) log(msgL int, format string, a ...interface{}) {

	if msgL > s.LogLevel {
		return
	}

	msglog(msgL, 2, format, a...)
}
1200379
func (c MultiLogger) Log(keyvals ...interface{}) {
	for _, l := range c {
		if !IsDisabled(l) {
			l.Log(keyvals...)
		}
	}
}
984815
func (l *syncLogger) Log(keyvals ...interface{}) error {
	l.mu.Lock()
	err := l.logger.Log(keyvals...)
	l.mu.Unlock()
	return err
}
1098944
func (t *Timer) Log(data Data) error {
	if data == nil {
		data = make(Data)
	}

	dur := t.Elapsed()

	if _, ok := data["elapsed"]; !ok {
		data["elapsed"] = t.durationUnit(dur)
	}

	t._statter.Timing(dur)
	return t.context.Log(data)
}
716794
func (l *IoLogger) Log(data Data) error {
	line := fmt.Sprintf("%s\n", BuildLog(data, l.AddTime))
	_, err := l.stream.Write([]byte(line))
	return err
}
249244
func (eng *Engine) log(format string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, "[%p]: %v", eng.transport, fmt.Sprintf(format, args...))
}
598640
func (l *CompositeLogger) Debugf(format string, v ...interface{}) {
	for _, log := range l.loggers {
		log.Debugf(format, v...)
	}
}
81722
func (o *Options) log(message string, LogLevel int, logVars ...interface{}) {
	if LogLevel <= o.LogLevel && !o.SkipLogging {
		o.Logger.Printf("[%s] [%s] "+message, append([]interface{}{LogLevelStrings[LogLevel]}, logVars...)...)
	}
}
1003238
func (m *Metrics) Log() {
	m.Lock()
	defer m.Unlock()

	log.Debug("Logging all timers")

	scale := time.Second
	du := float64(scale)
	units := scale.String()[1:]

	r := m.Registry

	r.Each(func(name string, i interface{}) {
		switch metric := i.(type) {
		// Other types/metrics shown in https://github.com/rcrowley/go-metrics/blob/master/log.go#L21
		case gometrics.Timer:
			t := metric.Snapshot()
			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
			log.WithFields(logrus.Fields{
				"count":     t.Count(),
				"sum":       fmt.Sprintf("%.4f", float64(t.Sum())/du),
				"min":       fmt.Sprintf("%.4f", float64(t.Min())/du),
				"max":       fmt.Sprintf("%.4f", float64(t.Max())/du),
				"mean":      fmt.Sprintf("%.4f", t.Mean()/du),
				"stddev":    fmt.Sprintf("%.4f", t.StdDev()/du),
				"median":    fmt.Sprintf("%.4f", ps[0]/du),
				"units":     units,
				"groupname": m.GroupName,
			}).Debug(name)
		}
	})

	// Disable and clear all metrics.
	m.Enabled = false
	r.UnregisterAll()
	m.Timers = make(map[string]gometrics.Timer)
}
20841
func (de *DefaultExtender) Log(logFlags LogFlags, msgLevel LogFlags, msg string) {
	if logFlags&msgLevel == msgLevel {
		log.Println(msg)
	}
}
537251
func Log(source string, r *Registry, d time.Duration) {
	for range time.Tick(d) {
		var parts []string
		for k, m := range r.Instruments() {
			switch i := m.(type) {
			case instruments.Discrete:
				s := i.Snapshot()
				parts = append(parts, fmt.Sprintf("sample#%s=%d", k, s))
			case instruments.Sample:
				s := instruments.Quantile(i.Snapshot(), 0.95)
				parts = append(parts, fmt.Sprintf("sample#%s=%d", k, s))
			}
		}
		log.Println(fmt.Sprintf("source=%s", source), strings.Join(parts, " "))
	}
}
1191295
func (f *Field) Log(x byte) int {
	if x == 0 {
		return -1
	}
	return int(f.log[x])
}
494493
func (l *RequestLogger) log(r *request.Request) {
	service := r.ClientInfo.ServiceName
	name := "?"
	if r.Operation != nil {
		name = r.Operation.Name
	}
	methodDescription := service + "/" + name

	glog.V(l.logLevel).Infof("AWS request: %s", methodDescription)
}
624420
func (logger *Logger) log(logClass LogClass, message string) {
	ld := logger.newLineData(logClass, message)
	b := &backgroundLineLogger{
		lineData: *ld,
		logger:   logger,
	}
	transitChannel <- b
}