Add configurable log timestamp format

example.config.toml

 # you have any issue.
 debug = true
 
+# Configures timestamp format in logs. The default is "unix-ms", which keeps
+# the existing numeric Unix milliseconds format for log aggregators.
+#
+# Presets:
+#   "unix"         Unix seconds
+#   "unix-ms"      Unix milliseconds
+#   "unix-micro"   Unix microseconds
+#   "unix-nano"    Unix nanoseconds
+#   "rfc3339"      RFC3339 string, honoring host timezone
+#   "rfc3339-nano" RFC3339Nano string, honoring host timezone
+#
+# Any other value is passed to Go's time formatter as a layout string.
+# log-time-format = "unix-ms"
+
 # A secret (required). Please remember that mtg supports only FakeTLS
 # mode, legacy simple and secured mode are prohibited. For you it means
 # that secret should either be base64-encoded or starts with ee.

internal/cli/run_proxy.go

 	"net"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/9seconds/mtg/v2/antireplay"
 	"github.com/9seconds/mtg/v2/events"
 )
 
 func makeLogger(conf *config.Config) mtglib.Logger {
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnixMs
+	zerolog.TimeFieldFormat = logTimeFormat(conf.LogTimeFormat)
 	zerolog.TimestampFieldName = "timestamp"
 	zerolog.LevelFieldName = "level"
 
 	return logger.NewZeroLogger(baseLogger)
 }
 
+func logTimeFormat(value string) string {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "", "unix-ms":
+		return zerolog.TimeFormatUnixMs
+	case "unix":
+		return zerolog.TimeFormatUnix
+	case "unix-micro":
+		return zerolog.TimeFormatUnixMicro
+	case "unix-nano":
+		return zerolog.TimeFormatUnixNano
+	case "rfc3339":
+		return time.RFC3339
+	case "rfc3339-nano":
+		return time.RFC3339Nano
+	default:
+		return value
+	}
+}
+
 func makeNetwork(conf *config.Config, version string) (mtglib.Network, error) {
 	resolver, err := network.GetDNS(conf.GetDNS())
 	if err != nil {

internal/cli/run_proxy_test.go

+package cli
+
+import (
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLogTimeFormat(t *testing.T) {
+	cases := []struct {
+		value string
+		want  string
+	}{
+		{value: "", want: zerolog.TimeFormatUnixMs},
+		{value: "unix-ms", want: zerolog.TimeFormatUnixMs},
+		{value: "unix", want: zerolog.TimeFormatUnix},
+		{value: "unix-micro", want: zerolog.TimeFormatUnixMicro},
+		{value: "unix-nano", want: zerolog.TimeFormatUnixNano},
+		{value: "rfc3339", want: time.RFC3339},
+		{value: "rfc3339-nano", want: time.RFC3339Nano},
+		{value: "2006-01-02 15:04:05", want: "2006-01-02 15:04:05"},
+	}
+
+	for _, c := range cases {
+		t.Run(c.value, func(t *testing.T) {
+			require.Equal(t, c.want, logTimeFormat(c.value))
+		})
+	}
+}

internal/config/config.go

 
 type Config struct {
 	Debug                       TypeBool        `json:"debug"`
+	LogTimeFormat               string          `json:"logTimeFormat"`
 	AllowFallbackOnUnknownDC    TypeBool        `json:"allowFallbackOnUnknownDc"`
 	Secret                      mtglib.Secret   `json:"secret"`
 	BindTo                      TypeHostPort    `json:"bindTo"`
 			Interval TypeDuration    `json:"interval"`
 			Count    TypeConcurrency `json:"count"`
 		} `json:"keepAlive"`
-		DOHIP            TypeIP         `json:"dohIp"`
-		DNS              TypeDNSURI     `json:"dns"`
-		Proxies          []TypeProxyURL `json:"proxies"`
-		TCPNotSentLowat  TypeBytes      `json:"tcpNotSentLowat"`
+		DOHIP           TypeIP         `json:"dohIp"`
+		DNS             TypeDNSURI     `json:"dns"`
+		Proxies         []TypeProxyURL `json:"proxies"`
+		TCPNotSentLowat TypeBytes      `json:"tcpNotSentLowat"`
 	} `json:"network"`
 	Stats struct {
 		StatsD struct {

internal/config/config_test.go

 	suite.Equal("0.0.0.0:3128", conf.BindTo.String())
 }
 
+func (suite *ConfigTestSuite) TestParseLogTimeFormat() {
+	conf, err := config.Parse([]byte(`
+secret = "7oe1GqLy6TBc38CV3jx7q09nb29nbGUuY29t"
+bind-to = "0.0.0.0:3128"
+log-time-format = "rfc3339"
+`))
+	suite.NoError(err)
+	suite.Equal("rfc3339", conf.LogTimeFormat)
+}
+
 func (suite *ConfigTestSuite) TestParsePublicIP() {
 	conf, err := config.Parse(suite.ReadConfig("public_ip.toml"))
 	suite.NoError(err)

internal/config/parse.go

 
 type tomlConfig struct {
 	Debug                       bool   `toml:"debug" json:"debug,omitempty"`
+	LogTimeFormat               string `toml:"log-time-format" json:"logTimeFormat,omitempty"`
 	AllowFallbackOnUnknownDC    bool   `toml:"allow-fallback-on-unknown-dc" json:"allowFallbackOnUnknownDc,omitempty"`
 	Secret                      string `toml:"secret" json:"secret"`
 	BindTo                      string `toml:"bind-to" json:"bindTo"`