// Trace enables debug tracing.
167409
func (r *RegexLexer) Trace(trace bool) *RegexLexer {
	r.trace = trace
	return r
}
865401
func (e *Echo) TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
	return e.Add(http.MethodTrace, path, h, m...)
}
290442
func (e *Error) trace(fields ...string) *Error {
	if e == nil {
		return nil
	}
	pc, file, line, _ := runtime.Caller(2)
	function := runtime.FuncForPC(pc).Name()
	_, function = filepath.Split(function)
	file = strings.TrimPrefix(file, rootPath+string(os.PathSeparator)) // trims project's root path.
	tp := TracePoint{}
	if len(fields) > 0 {
		tp = TracePoint{Line: line, Filename: file, Function: function, Env: map[string][]string{"Tags": fields}}
	} else {
		tp = TracePoint{Line: line, Filename: file, Function: function}
	}
	e.CallTrace = append(e.CallTrace, tp)
	return e
}
641969
func Traceback(l, l1 *State, message string, level int) {
	const levels1, levels2 = 12, 10
	levels := countLevels(l1)
	mark := 0
	if levels > levels1+levels2 {
		mark = levels1
	}
	buf := message
	if buf != "" {
		buf += "\n"
	}
	buf += "stack traceback:"
	for f, ok := Stack(l1, level); ok; f, ok = Stack(l1, level) {
		if level++; level == mark {
			buf += "\n\t..."
			level = levels - levels2
		} else {
			d, _ := Info(l1, "Slnt", f)
			buf += "\n\t" + d.ShortSource + ":"
			if d.CurrentLine > 0 {
				buf += fmt.Sprintf("%d:", d.CurrentLine)
			}
			buf += " in " + functionName(l, d)
			if d.IsTailCall {
				buf += "\n\t(...tail calls...)"
			}
		}
	}
	l.PushString(buf)
}
1371618
func (entry *Entry) Debug(args ...interface{}) {
	if logger.Level >= logrus.DebugLevel {
		entry.Entry.Debug(args...)
	}
}
365695
func Trace(id, description string, keysAndValues ...interface{}) {
	keysAndValues = append([]interface{}{"golog_id", id}, keysAndValues...)
	(DefaultLogger.(*logger)).trace(1, description, keysAndValues...)
}
538335
func (e *Error) Trace(fields ...string) *Error {
	if e == nil {
		return nil
	}

	e.lock.Lock()
	defer e.lock.Unlock()

	return e.trace(fields...)
}
248273
func (logs *Logs) Trace(v ...interface{}) {
	logs.TRACE().Output(2, fmt.Sprintln(v...))
}
576385
func (q *Queryx) Trace(trace gocql.Tracer) *Queryx {
	q.Query.Trace(trace)
	return q
}
1103468
func (t LoggerType) Trace(errin error) {
	if errin == nil {
		return
	}

	msgopts, err := t.options.Formatter.formatSkip(errin.Error(), 1, true)
	if err != nil {
		t.options.FallbackLogger.Trace(ErrSlackFormatFailed1.New(err, errin.Error()))
		t.options.FallbackLogger.Trace(errin)
		return
	}

	t.sendMessage(t.options.ChannelError, msgopts...)
}
248597
func trace(message string, err error) {
	pc := make([]uintptr, 10)
	runtime.Callers(2, pc)
	f := runtime.FuncForPC(pc[0])
	file, line := f.FileLine(pc[0])
	if err != nil {
		log.Printf("%s:%d %s: %s\n", file, line, f.Name(), err)
	} else {
		log.Printf("%s:%d %s: %s\n", file, line, f.Name(), message)
	}
}
1144319
func (ml *MockRouteCountLogger) TraceD(title string, data map[string]interface{}) {
	ml.logger.TraceD(title, data)
}
1106001
func Trace(format string, err error, fields logrus.Fields, a ...interface{}) {
	if traceEnabled {
		log.WithError(err).WithFields(fields).Debugf(format)
	}
}
594182
func trace(ctx context.Context, subsystem, name string) (opentracing.Span, context.Context) {
	span, ctx := opentracing.StartSpanFromContext(ctx, name)

	span.SetTag("subsystem", subsystem)

	// This is slightly confusing: when tracing is disabled, trace spans
	// are still created - but the tracer used is a NOP. Therefore, only
	// display the message when tracing is really enabled.
	if tracing {
		agentLog.Debugf("created span %v", span)
	}

	return span, ctx
}
712250
func (me *Database) Trace(op, sql string, args ...interface{}) {
	if me.logger != nil {
		if sql != "" {
			if len(args) != 0 {
				me.logger.Printf("[goqu] %s [query:=`%s` args:=%+v]", op, sql, args)
			} else {
				me.logger.Printf("[goqu] %s [query:=`%s`]", op, sql)
			}
		} else {
			me.logger.Printf("[goqu] %s", op)
		}
	}
}
230315
func (l *Logger) Debug(v ...interface{}) {
	l.Fprint(l.flags, LEVEL_DEBUG, 2, fmt.Sprint(v...), nil)
}
1032606
func tracef(format string, v ...interface{}) {
	if logLevel >= Trace {
		logger.Printf(format, v...)
	}
}