How to add file:line info at the end of the log message?

[nirs]

It easy to add file:line info using:

	log := zap.New(zap.UseFlagOptions(&zap.Options{
		Development: true,
		ZapOpts: []uberzap.Option{
			uberzap.AddCaller(),
		},
		TimeEncoder: zapcore.ISO8601TimeEncoder,
	}))

But this add the information in the worst place - before the log message:

2024-10-22T16:15:37.201+0530	INFO	dractions/actions.go:115	enter Failover appset-deploy-cephfs-busybox
2024-10-22T16:15:37.273+0530	INFO	dractions/retry.go:67	drpc appset-deploy-cephfs-busybox is ready
2024-10-22T16:15:37.432+0530	INFO	dractions/actions.go:187	update drpc appset-deploy-cephfs-busybox failover to rdr-dr1

The most impport part of the log is the message, not the location of the call. If you want to find the log line in the code, having a file:line is useful, but it does not mean this info must come before the message.

This also make the log much harder to read because the way the fileds are separated by tabs. If we put the info at the end, the log is nicely indented:

2024-10-22T16:15:37.201+0530	INFO	enter Failover appset-deploy-cephfs-busybox	dractions/actions.go:115
2024-10-22T16:15:37.273+0530	INFO	drpc appset-deploy-cephfs-busybox is ready	dractions/retry.go:67
2024-10-22T16:15:37.432+0530	INFO	update drpc appset-deploy-cephfs-busybox failover to rdr-dr1	dractions/actions.go:187

Or maybe add the info as a key value pair at the end, the same way other key-value pairs are added:

timestamp level message {"loc": "dractions/actions.go:115"}

Do we have a way to control the order?

[nirs]

Checking the shows that the caller info is hardcoded and there is no way to control the order except writing our own encoder.

func (c consoleEncoder) EncodeEntry(ent Entry, fields []Field) (*buffer.Buffer, error) {
	line := bufferpool.Get()

	// We don't want the entry's metadata to be quoted and escaped (if it's
	// encoded as strings), which means that we can't use the JSON encoder. The
	// simplest option is to use the memory encoder and fmt.Fprint.
	//
	// If this ever becomes a performance bottleneck, we can implement
	// ArrayEncoder for our plain-text format.
	arr := getSliceEncoder()
	if c.TimeKey != "" && c.EncodeTime != nil && !ent.Time.IsZero() {
		c.EncodeTime(ent.Time, arr)
	}
	if c.LevelKey != "" && c.EncodeLevel != nil {
		c.EncodeLevel(ent.Level, arr)
	}
	if ent.LoggerName != "" && c.NameKey != "" {
		nameEncoder := c.EncodeName

		if nameEncoder == nil {
			// Fall back to FullNameEncoder for backward compatibility.
			nameEncoder = FullNameEncoder
		}

		nameEncoder(ent.LoggerName, arr)
	}
	if ent.Caller.Defined {
		if c.CallerKey != "" && c.EncodeCaller != nil {
			c.EncodeCaller(ent.Caller, arr)
		}
		if c.FunctionKey != "" {
			arr.AppendString(ent.Caller.Function)
		}
	}
	for i := range arr.elems {
		if i > 0 {
			line.AppendString(c.ConsoleSeparator)
		}
		_, _ = fmt.Fprint(line, arr.elems[i])
	}
	putSliceEncoder(arr)

	// Add the message itself.
	if c.MessageKey != "" {
		c.addSeparatorIfNecessary(line)
		line.AppendString(ent.Message)
	}

	// Add any structured context.
	c.writeContext(line, fields)

	// If there's no stacktrace key, honor that; this allows users to force
	// single-line output.
	if ent.Stack != "" && c.StacktraceKey != "" {
		line.AppendByte('\n')
		line.AppendString(ent.Stack)
	}

	line.AppendString(c.LineEnding)
	return line, nil
}