log

Basic example shows a simple log observer and using the logging functions.

package main

import (
	"fmt"
	"strings"

	"github.com/gliderlabs/comlab/pkg/log"
)

type LogPrinter struct{}

// This Observer iterates over the event Index to maintain order of fields,
// and creates a list of comma separated key-value pairs to print out.
func (lp LogPrinter) Log(event log.Event) {
	var fields []string
	for _, key := range event.Index {
		fields = append(fields, fmt.Sprintf("%s=%s", key, event.Fields[key]))
	}
	fmt.Println(strings.Join(fields, ", "))
}

// Basic example shows a simple log observer and using the logging functions.
func main() {
	log.RegisterObserver(LogPrinter{})
	log.Info("Hello world", log.Fields{"foo": "bar"}, 12345)
}

Output:
msg=Hello world, foo=bar, data=12345

FieldProcessor example shows using the field processor callback to support new types.

package main

import (
	"strconv"

	"github.com/gliderlabs/comlab/pkg/log"
)

type CustomData struct {
	Foo string
	Bar string
}

func fieldProcessor(e log.Event, field interface{}) (log.Event, bool) {
	switch obj := field.(type) {
	case int:
		return e.Append("num", strconv.Itoa(obj)), true
	case CustomData:
		e = e.Append("custom.foo", obj.Foo)
		e = e.Append("custom.bar", obj.Bar)
		return e, true
	}
	return e, false
}

// FieldProcessor example shows using the field processor callback to support new types.
func main() {
	log.RegisterObserver(LogPrinter{})
	log.SetFieldProcessor(fieldProcessor)
	log.Info("Hello world", 12345, CustomData{"FOO", "BAR"})
}

Output:
msg=Hello world, num=12345, custom.foo=FOO, custom.bar=BAR

HTTP example shows using the ResponseWriter wrapper for HTTP logging

package main

import (
	"net/http"
	"strconv"
	"time"

	"github.com/gliderlabs/comlab/pkg/log"
)

// our field processor will need to know how to process HTTP related types
func httpFieldProcessor(e log.Event, field interface{}) (log.Event, bool) {
	switch obj := field.(type) {
	case time.Duration:
		return e.Append("dur", strconv.Itoa(int(obj/time.Millisecond))), true
	case log.ResponseWriter:
		e = e.Append("bytes", strconv.Itoa(obj.Size()))
		e = e.Append("status", strconv.Itoa(obj.Status()))
		return e, true
	case *http.Request:
		e = e.Append("ip", obj.RemoteAddr)
		e = e.Append("method", obj.Method)
		e = e.Append("path", obj.RequestURI)
		return e, true
	}
	return e, false
}

// our logging middleware that injects a wrapped ResponseWriter
func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t := time.Now()
		lw := log.WrapResponseWriter(w)
		defer log.Info(r, lw, time.Now().Sub(t))
		next.ServeHTTP(lw, r)
	})
}

// HTTP example shows using the ResponseWriter wrapper for HTTP logging
func main() {
	log.SetFieldProcessor(httpFieldProcessor)

	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("This is a catch-all route"))
	})

	// wrap our mux with our middleware
	http.ListenAndServe(":8080", loggingMiddleware(mux))
}

Output: