How to send HTTP request when "log.Fatal()" is executed?

I want to send logs to my HTTP server when the "log.Fatal()" is called without any extra code for every log statement. Changing/overwriting the default behaviour of log.Info(), log.Fatal(), etc. would be fantastic.

You can create a wrapper module for builtin log

yourproject/log/log.go

package log
import goLog "log"
func Fatal(v ...interface{}) {
   goLog.Fatal(v...)
   // send request ...
   // reqQueue <- some args
}

replace log module with the wrapper in your project

// import "log"
import "yourproject/log"

func Foo() {
    log.Fatal(err)
}

Try creating a type that wraps the standard Logger type, but with your desired enhancement. Then by creating an instance of it called "log" which wraps the default logger, you can continue to use logging in your code in the same way with minimal changes required (since it will have the same name as the log package, and retain *all of the methods).

package main

import _log "log"

type WrappedLogger struct {
    // This field has no name, so we retain all the Logger methods
    *_log.Logger
}

// here we override the behaviour of log.Fatal
func (l *WrappedLogger) Fatal(v ...interface{}) {
    l.Println("doing the HTTP request")
    /// do HTTP request

    // now call the original Fatal method from the underlying logger
    l.Logger.Fatal(v...)
}

// wrapping the default logger, but adding our new method.
var log = WrappedLogger{_log.Default()}

func main() {
    // notice we can still use Println
    log.Println("hello")
    // but now Fatal does the special behaviour
    log.Fatal("fatal log")
}

*The only gotcha here is that we've replaced the typical log package with a log instance. In many ways, it behaves the same, since most of the functions in the log package are set up as forwards to the default Logger instance for convenience.

However, this means that our new log won't have access to the "true" functions from the log package, such as log.New. For that, you will need to reference the alias to the original package.

// want to create a new logger?
_log.New(out, prefix, flag)