How to Simulate Monkey Patching in Go Using Interfaces and Reflection

Introduction

Monkey patching is a technique that modifies or extends the behavior of a library or object at runtime without changing its original source code. While useful in dynamic languages like Python, it is generally discouraged because it can make code harder to understand, maintain, and upgrade.

Go is a statically typed, compiled language that does not directly support monkey patching. Its design philosophy favors explicitness and simplicity, encouraging the use of interfaces and composition for extensibility and testability. Nevertheless, Go developers can achieve similar effects through creative use of interfaces, reflection, and wrapper types.

Using Interfaces to Achieve Monkey‑Patch‑Like Behavior

Define a logger interface and a simple implementation:

type Logger interface {
    Log(message string)
}

type SimpleLogger struct{}

func (l SimpleLogger) Log(message string) {
    fmt.Println(message)
}

Create a new type that embeds the original logger and adds a log level:

type LevelLogger struct {
    logger Logger // embed Logger interface
    level  string
}

func (l LevelLogger) Log(message string) {
    l.logger.Log(fmt.Sprintf("[%s] %s", l.level, message))
}

Using Reflection for Dynamic Modification

Reflection allows runtime inspection and invocation of methods. Although powerful, it can reduce readability and performance, so it should be used sparingly.

Below is a function that wraps any Logger with a log‑level decorator using reflection:

func AddLogLevel(logger Logger, level string) Logger {
    return &levelLogger{logger: logger, level: level}
}

type levelLogger struct {
    logger Logger
    level  string
}

func (l *levelLogger) Log(message string) {
    // Dynamically call the original Log method via reflection
    reflect.ValueOf(l.logger).MethodByName("Log").Call([]reflect.Value{
        reflect.ValueOf(fmt.Sprintf("[%s] %s", l.level, message)),
    })
}

Example usage:

func main() {
    logger := SimpleLogger{}
    loggerWithLevel := AddLogLevel(logger, "INFO")
    loggerWithLevel.Log("this is an info log")
}

The AddLogLevel function returns a new Logger implementation that, when its Log method is called, first adds the specified level and then forwards the call to the original logger via reflection.

Caution and Best Practices

While reflection can simulate monkey patching, it introduces performance overhead and can make code harder to understand. Prefer Go’s native mechanisms—interfaces and composition—whenever possible, and reserve reflection for cases where other approaches are impractical.

Conclusion

Go does not provide built‑in monkey patching, but developers can safely extend functionality using interface‑based wrappers or, when necessary, reflection. These techniques maintain type safety and keep code maintainable, provided they are applied judiciously.