////////////////////////////////////////////////////////////////////////////////
// debugInfoLog adds a line to the triage debug log and Infof log.
507982
func (op *triageOp) debugInfoLog(c context.Context, format string, args ...interface{}) {
	logging.Infof(c, format, args...)
	op.appendToLog(c, fmt.Sprintf(format, args...))
}
1055333
func (l *SysLogger) Debugf(format string, v ...interface{}) {
	if l.debug {
		l.writer.Debug(fmt.Sprintf(format, v...))
	}
}
1273422
func (c *Connection) debugLog(
	fuseID uint64,
	calldepth int,
	format string,
	v ...interface{}) {
	if c.debugLogger == nil {
		return
	}

	// Get file:line info.
	var file string
	var line int
	var ok bool

	_, file, line, ok = runtime.Caller(calldepth)
	if !ok {
		file = "???"
	}

	fileLine := fmt.Sprintf("%v:%v", path.Base(file), line)

	// Format the actual message to be printed.
	msg := fmt.Sprintf(
		"Op 0x%08x %24s] %v",
		fuseID,
		fileLine,
		fmt.Sprintf(format, v...))

	// Print it.
	c.debugLogger.Println(msg)
}
554261
function logAssertion(details) {
  		runLoggingCallbacks("log", details);

  		var assertion = {
  			passed: details.result,
  			actual: details.actual,
  			expected: details.expected,
  			message: details.message,
  			stack: details.source,
  			todo: details.todo
  		};
  		this.testReport.pushAssertion(assertion);
  		emit("assertion", assertion);
  	}
268857
func SetDebugInfo(err error, meta metadata.MD) {
	if _, ok := err.(*trace.TraceErr); !ok {
		return
	}
	out, err := json.Marshal(err)
	if err != nil {
		return
	}
	meta[DebugReportMetadata] = []string{
		base64.StdEncoding.EncodeToString(out),
	}
}
756981
private void infoOrDebug( boolean info, String msg )
    {
        if ( info )
        {
            getLogger().info( msg );
        }
        else
        {
            getLogger().debug( msg );
        }
    }
538740
function log(type, label, data) {
	var typeLabel = type.charAt(0).toUpperCase() + type.slice(1);
	var color;

	if (typeLabel === 'Error') {
		typeLabel = chalk.red(typeLabel);
		color = 'red';
	} else if (typeLabel === 'Warn') {
		typeLabel = chalk.yellow(typeLabel);
		color = 'yellow';
	} else if (typeLabel === 'Info') {
		typeLabel = chalk.green(typeLabel);
		color = 'green';
	} else if (typeLabel === 'Log') {
		typeLabel = chalk.gray(typeLabel);
		color = 'gray';
	}

	// used to avoid logging "undefined" in the console
	if (useTypeLabels) {
		label = typeLabel + ': ' + chalk.cyan(label);
	} else {
		label = chalk[color](label);
	}
	if (data) {
		console[type](label, data);
	} else {
		console[type](label);
	}
}
819478
func Infof(format string, i ...interface{}) {
	if gLogLevel <= LInfo {
		logMessage("INFO - ", fmt.Sprintf(format, i...))
	}
}
38513
func (l logger) Debugf(format string, args ...interface{}) {
	l.entry.Debugf(format, args...)
}
643110
func DebugLogging(c *Client) {
	c.Handlers.Send.Prepend(request.RequestLogger)
	c.Handlers.Send.Append(request.ResponseLogger)
}
140227
func (l *Logger) Debugf(msg string, params ...interface{}) {
	if l.shouldAppend(DEBUG) {
		l.makeLog(fmt.Sprintf(msg, params...), DEBUG, nil)
	}
}
8023
func (l *BeeLogger) Debug(message string, file string, line int) {
	l.mustLogDebug(message, file, line)
}
1322444
func logDebug(source, format string, v ...interface{}) {
	if EnableDebugLogging {
		stdLogger.Printf(fmt.Sprintf("[DEBUG] %s %s", source, format), v...)
	}
}
152670
func Debugf(logger *gosteno.Logger, msg string, inputs ...interface{}) {
	switch logger.Level() {
	case gosteno.LOG_DEBUG, gosteno.LOG_DEBUG1, gosteno.LOG_DEBUG2:
		logger.Debugf(msg, inputs...)
	}
}
1307301
func (l *Log) Debugf(format string, args ...interface{}) {
	opts := getLoggerOpts(l.module, api.DEBUG)
	if !opts.levelEnabled {
		return
	}
	if l.loadCustomLogger() {
		l.customLogger.Debugf(format, args...)
		return
	}
	l.logf(opts, api.DEBUG, format, args...)
}
969442
func Debug(logger log.Logger) log.Logger {
	return log.WithPrefix(logger, Key(), DebugValue())
}
728114
func (g *GLogger) Infof(format string, args ...interface{}) {
	// GRPC is very verbose, so this is intentionally
	// pushes info level statements as Teleport's debug level ones
	g.Entry.Debugf(format, args...)
}