tracker.go

package main

import (
	"log"
	"os"
	"strings"
	"time"
)

type EventType int

const (
	Timer EventType = iota
	Counter
	Gauge
	Set
)

func (et *EventType) String() string {
	switch *et {
	case Timer:
		return "Timer"
	case Counter:
		return "Counter"
	case Gauge:
		return "Gauge"
	case Set:
		return "Set"
	default:
		return "Unknown"
	}
}

type Event struct {
	Event      string                 `json:"event"`
	Properties map[string]interface{} `json:"properties,omitempty"`
}

func NewEvent(event string, properties map[string]interface{}) *Event {
	if properties == nil {
		properties = make(map[string]interface{})
	}

	return &Event{Event: event, Properties: properties}
}

func NewDurationEvent(stat string, start time.Time, properties map[string]interface{}) *Event {
	if properties == nil {
		properties = make(map[string]interface{})
	}
	event := NewEvent(stat, properties)
	event.Properties["Value"] = time.Since(start)
	event.Properties["Type"] = Timer
	return event
}

type Tracker interface {
	Track(event *Event) error
}

func (wrapper *ProxyHttpServerWrapper) TrackEvent(event *Event) error {
	return wrapper.Tracker.Track(event)
}

func (wrapper *ProxyHttpServerWrapper) TrackDuration(event *Event, start time.Time) error {
	new_event := NewDurationEvent(event.Event, start, event.Properties)
	return wrapper.Tracker.Track(new_event)
}

type LogTracker struct {
	*log.Logger
}

func NewLogTracker(logger *log.Logger) *LogTracker {
	if logger == nil {
		logger = log.New(os.Stderr, "", log.LstdFlags)
	}
	return &LogTracker{logger}
}

func (lt *LogTracker) Track(event *Event) error {
	lt.Printf("%s - %v", event.Event, event.Properties)
	return nil
}

type NoopTracker struct{}

func NewNoopTracker() *NoopTracker {
	return &NoopTracker{}
}

func (nt *NoopTracker) Track(event *Event) error {
	return nil
}

type CompositeTracker struct {
	trackers []Tracker
}

func NewCompositeTracker(trackers ...Tracker) *CompositeTracker {
	composite_tracker := &CompositeTracker{make([]Tracker, 0)}
	for _, tracker := range trackers {
		composite_tracker.trackers = append(composite_tracker.trackers,
			tracker)
	}
	return composite_tracker
}

func (ct *CompositeTracker) AddTracker(tracker Tracker) {
	ct.trackers = append(ct.trackers, tracker)
}

type CompositeError []error

func (ce *CompositeError) Error() string {
	error_strings := make([]string, len(*ce))
	for _, err := range *ce {
		error_strings = append(error_strings, err.Error())
	}
	return strings.Join(error_strings[:], "\n")
}

func (st *CompositeTracker) Track(event *Event) error {
	errors := make([]error, 0)
	errs := CompositeError(errors)
	for _, tracker := range st.trackers {
		err = tracker.Track(event)
		if err != nil {
			errs = append(errs, err)
		}
	}
	return &errs
}