snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/public/pluginapi/experimental/bot/logger/admincclogger/admincc_logger.go

@@ -0,0 +1,97 @@
+package admincclogger
+
+import (
+	"fmt"
+
+	"github.com/mattermost/mattermost/server/public/pluginapi/experimental/bot/logger"
+	"github.com/mattermost/mattermost/server/public/pluginapi/experimental/bot/poster"
+	"github.com/mattermost/mattermost/server/public/pluginapi/experimental/common"
+)
+
+type adminCCLogger struct {
+	logger.Logger
+	dmer           poster.DMer
+	logLevel       logger.LogLevel
+	includeContext bool
+	userIDs        []string
+}
+
+/*
+New promotes the provided logger into a admin cc logger, sending direct messages to all the admin
+ids provided through the dmer provided, about all events below the logLevel. If logVerbose is set,
+it will also send the context.
+
+- l Logger: A logger to promote.
+
+- dmer DMer: A DMer to send the messages to the admins.
+
+- logLevel: The highest type of message to be stored in telemetry.
+
+- includeContext: Whether the log context should be messaged to the admins.
+
+- userIDs: The user IDs of the admins.
+*/
+func New(l logger.Logger, dmer poster.DMer, logLevel logger.LogLevel, includeContext bool, userIDs ...string) logger.Logger {
+	return &adminCCLogger{
+		Logger:         l,
+		dmer:           dmer,
+		logLevel:       logLevel,
+		includeContext: includeContext,
+		userIDs:        userIDs,
+	}
+}
+
+// NewFromAPI creates a adminCCLogger directly from a LogAPI instead of passing a logger.
+func NewFromAPI(api common.LogAPI, dmer poster.DMer, logLevel logger.LogLevel, includeContext bool, userIDs ...string) logger.Logger {
+	return New(logger.New(api), dmer, logLevel, includeContext, userIDs...)
+}
+
+func (l *adminCCLogger) Debugf(format string, args ...any) {
+	l.Logger.Debugf(format, args...)
+	message := fmt.Sprintf(format, args...)
+	if logger.Level(l.logLevel) >= 4 {
+		l.logToAdmins("DEBUG", message)
+	}
+}
+
+func (l *adminCCLogger) Errorf(format string, args ...any) {
+	l.Logger.Errorf(format, args...)
+	message := fmt.Sprintf(format, args...)
+	if logger.Level(l.logLevel) >= 1 {
+		l.logToAdmins("ERROR", message)
+	}
+}
+
+func (l *adminCCLogger) Infof(format string, args ...any) {
+	l.Logger.Infof(format, args...)
+	message := fmt.Sprintf(format, args...)
+	if logger.Level(l.logLevel) >= 3 {
+		l.logToAdmins("INFO", message)
+	}
+}
+
+func (l *adminCCLogger) Warnf(format string, args ...any) {
+	l.Logger.Warnf(format, args...)
+	message := fmt.Sprintf(format, args...)
+	if logger.Level(l.logLevel) >= 2 {
+		l.logToAdmins("WARN", message)
+	}
+}
+
+func (l *adminCCLogger) logToAdmins(level, message string) {
+	context := l.Context()
+	if l.includeContext && len(context) > 0 {
+		message += "\n" + common.JSONBlock(context)
+	}
+	_ = l.dmAdmins("(log %s) %s", level, message)
+}
+
+func (l *adminCCLogger) dmAdmins(format string, args ...any) error {
+	for _, id := range l.userIDs {
+		_, err := l.dmer.DM(id, format, args...)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

server/public/pluginapi/experimental/bot/logger/default_logger.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2019-present Mattermost, Inc. All Rights Reserved.
+// See License for license information.
+
+package logger
+
+import (
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/mattermost/mattermost/server/public/pluginapi/experimental/common"
+)
+
+type defaultLogger struct {
+	logContext LogContext
+	logAPI     common.LogAPI
+}
+
+/*
+New creates a new logger.
+
+- api: LogAPI implementation
+*/
+func New(api common.LogAPI) Logger {
+	l := &defaultLogger{
+		logAPI: api,
+	}
+	return l
+}
+
+func (l *defaultLogger) With(logContext LogContext) Logger {
+	newLogger := *l
+	if len(newLogger.logContext) == 0 {
+		newLogger.logContext = map[string]any{}
+	}
+	maps.Copy(newLogger.logContext, logContext)
+	return &newLogger
+}
+
+func (l *defaultLogger) WithError(err error) Logger {
+	newLogger := *l
+	if len(newLogger.logContext) == 0 {
+		newLogger.logContext = map[string]any{}
+	}
+	newLogger.logContext[ErrorKey] = err.Error()
+	return &newLogger
+}
+
+func (l *defaultLogger) Context() LogContext {
+	return l.logContext
+}
+
+func (l *defaultLogger) Timed() Logger {
+	return l.With(LogContext{
+		timed: time.Now(),
+	})
+}
+
+func (l *defaultLogger) Debugf(format string, args ...any) {
+	measure(l.logContext)
+	message := fmt.Sprintf(format, args...)
+	l.logAPI.LogDebug(message, toKeyValuePairs(l.logContext)...)
+}
+
+func (l *defaultLogger) Errorf(format string, args ...any) {
+	measure(l.logContext)
+	message := fmt.Sprintf(format, args...)
+	l.logAPI.LogError(message, toKeyValuePairs(l.logContext)...)
+}
+
+func (l *defaultLogger) Infof(format string, args ...any) {
+	measure(l.logContext)
+	message := fmt.Sprintf(format, args...)
+	l.logAPI.LogInfo(message, toKeyValuePairs(l.logContext)...)
+}
+
+func (l *defaultLogger) Warnf(format string, args ...any) {
+	measure(l.logContext)
+	message := fmt.Sprintf(format, args...)
+	l.logAPI.LogWarn(message, toKeyValuePairs(l.logContext)...)
+}

server/public/pluginapi/experimental/bot/logger/logger.go

@@ -0,0 +1,78 @@
+package logger
+
+import "time"
+
+const (
+	timed   = "__since"
+	elapsed = "Elapsed"
+
+	ErrorKey = "error"
+)
+
+// LogLevel defines the level of log messages
+type LogLevel string
+
+const (
+	// LogLevelDebug denotes debug messages
+	LogLevelDebug = "debug"
+	// LogLevelInfo denotes info messages
+	LogLevelInfo = "info"
+	// LogLevelWarn denotes warn messages
+	LogLevelWarn = "warn"
+	// LogLevelError denotes error messages
+	LogLevelError = "error"
+)
+
+// LogContext defines the context for the logs.
+type LogContext map[string]any
+
+// Logger defines an object able to log messages.
+type Logger interface {
+	// With adds a logContext to the logger.
+	With(LogContext) Logger
+	// WithError adds an Error to the logger.
+	WithError(error) Logger
+	// Context returns the current context
+	Context() LogContext
+	// Timed add a timed log context.
+	Timed() Logger
+	// Debugf logs a formatted string as a debug message.
+	Debugf(format string, args ...any)
+	// Errorf logs a formatted string as an error message.
+	Errorf(format string, args ...any)
+	// Infof logs a formatted string as an info message.
+	Infof(format string, args ...any)
+	// Warnf logs a formatted string as an warning message.
+	Warnf(format string, args ...any)
+}
+
+func measure(lc LogContext) {
+	if lc[timed] == nil {
+		return
+	}
+	started := lc[timed].(time.Time)
+	lc[elapsed] = time.Since(started).String()
+	delete(lc, timed)
+}
+
+// Level assigns an integer to the LogLevel string
+func Level(l LogLevel) int {
+	switch l {
+	case LogLevelDebug:
+		return 4
+	case LogLevelInfo:
+		return 3
+	case LogLevelWarn:
+		return 2
+	case LogLevelError:
+		return 1
+	}
+	return 0
+}
+
+func toKeyValuePairs(in map[string]any) (out []any) {
+	for k, v := range in {
+		out = append(out, k, v)
+	}
+	return out
+}

server/public/pluginapi/experimental/bot/logger/nil_logger.go

@@ -0,0 +1,17 @@
+package logger
+
+type nilLogger struct{}
+
+// NewNilLogger returns a logger that performs no action.
+func NewNilLogger() Logger {
+	return &nilLogger{}
+}
+
+func (l *nilLogger) With(LogContext) Logger { return l }
+func (l *nilLogger) WithError(error) Logger { return l }
+func (l *nilLogger) Context() LogContext    { return nil }
+func (l *nilLogger) Timed() Logger          { return l }
+func (l *nilLogger) Debugf(string, ...any)  {}
+func (l *nilLogger) Errorf(string, ...any)  {}
+func (l *nilLogger) Infof(string, ...any)   {}
+func (l *nilLogger) Warnf(string, ...any)   {}

server/public/pluginapi/experimental/bot/logger/test_logger.go

@@ -0,0 +1,60 @@
+package logger
+
+import (
+	"fmt"
+	"maps"
+	"testing"
+	"time"
+)
+
+type testLogger struct {
+	testing.TB
+	logContext LogContext
+}
+
+// NewTestLogger creates a logger for testing purposes.
+func NewTestLogger() Logger {
+	return &testLogger{}
+}
+
+func (l *testLogger) With(logContext LogContext) Logger {
+	newl := *l
+	if len(newl.logContext) == 0 {
+		newl.logContext = map[string]any{}
+	}
+	maps.Copy(newl.logContext, logContext)
+	return &newl
+}
+
+func (l *testLogger) WithError(err error) Logger {
+	newl := *l
+	if len(newl.logContext) == 0 {
+		newl.logContext = map[string]any{}
+	}
+	newl.logContext[ErrorKey] = err.Error()
+	return &newl
+}
+
+func (l *testLogger) Context() LogContext {
+	return l.logContext
+}
+
+func (l *testLogger) Timed() Logger {
+	return l.With(LogContext{
+		timed: time.Now(),
+	})
+}
+
+func (l *testLogger) logf(prefix, format string, args ...any) {
+	out := fmt.Sprintf(prefix+": "+format, args...)
+	if len(l.logContext) > 0 {
+		measure(l.logContext)
+		out += fmt.Sprintf(" -- %+v", l.logContext)
+	}
+	l.TB.Log(out)
+}
+
+func (l *testLogger) Debugf(format string, args ...any) { l.logf("DEBUG", format, args...) }
+func (l *testLogger) Errorf(format string, args ...any) { l.logf("ERROR", format, args...) }
+func (l *testLogger) Infof(format string, args ...any)  { l.logf("INFO", format, args...) }
+func (l *testLogger) Warnf(format string, args ...any)  { l.logf("WARN", format, args...) }