chrly/eventsubscribers/stats_reporter.go

package eventsubscribers

import (
	"context"
	"net/http"
	"strings"
	"sync"
	"time"

	"github.com/mono83/slf"

	"github.com/elyby/chrly/api/mojang"
)

type StatsReporter struct {
	slf.StatsReporter
	Prefix string

	timersMap   map[string]time.Time
	timersMutex sync.Mutex
}

type Reporter interface {
	Enable(reporter slf.StatsReporter)
}

type ReporterFunc func(reporter slf.StatsReporter)

func (f ReporterFunc) Enable(reporter slf.StatsReporter) {
	f(reporter)
}

// TODO: rework all reporters in the same style as AvailableRedisPoolSizeReporter
func (s *StatsReporter) ConfigureWithDispatcher(d Subscriber) {
	s.timersMap = make(map[string]time.Time)

	// Per request events
	d.Subscribe("skinsystem:before_request", s.handleBeforeRequest)
	d.Subscribe("skinsystem:after_request", s.handleAfterRequest)

	// Authentication events
	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.success"))
	d.Subscribe("authentication:error", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
	d.Subscribe("authentication:error", s.incCounterHandler("authentication.failed"))

	// Mojang signed textures source events
	d.Subscribe("mojang_textures:call", s.incCounterHandler("mojang_textures.request"))
	d.Subscribe("mojang_textures:usernames:after_cache", func(username string, uuid string, found bool, err error) {
		if err != nil || !found {
			return
		}

		if uuid == "" {
			s.IncCounter("mojang_textures.usernames.cache_hit_nil", 1)
		} else {
			s.IncCounter("mojang_textures.usernames.cache_hit", 1)
		}
	})
	d.Subscribe("mojang_textures:textures:after_cache", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
		if err != nil {
			return
		}

		if textures != nil {
			s.IncCounter("mojang_textures.textures.cache_hit", 1)
		}
	})
	d.Subscribe("mojang_textures:already_processing", s.incCounterHandler("mojang_textures.already_scheduled"))
	d.Subscribe("mojang_textures:usernames:after_call", func(username string, profile *mojang.ProfileInfo, err error) {
		if err != nil {
			return
		}

		if profile == nil {
			s.IncCounter("mojang_textures.usernames.uuid_miss", 1)
		} else {
			s.IncCounter("mojang_textures.usernames.uuid_hit", 1)
		}
	})
	d.Subscribe("mojang_textures:textures:before_call", s.incCounterHandler("mojang_textures.textures.request"))
	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
		if err != nil {
			return
		}

		if textures == nil {
			s.IncCounter("mojang_textures.usernames.textures_miss", 1)
		} else {
			s.IncCounter("mojang_textures.usernames.textures_hit", 1)
		}
	})
	d.Subscribe("mojang_textures:before_result", func(username string, uuid string) {
		s.startTimeRecording("mojang_textures_result_time_" + username)
	})
	d.Subscribe("mojang_textures:after_result", func(username string, textures *mojang.SignedTexturesResponse, err error) {
		s.finalizeTimeRecording("mojang_textures_result_time_"+username, "mojang_textures.result_time")
	})
	d.Subscribe("mojang_textures:textures:before_call", func(uuid string) {
		s.startTimeRecording("mojang_textures_provider_time_" + uuid)
	})
	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
		s.finalizeTimeRecording("mojang_textures_provider_time_"+uuid, "mojang_textures.textures.request_time")
	})

	// Mojang UUIDs batch provider metrics
	d.Subscribe("mojang_textures:batch_uuids_provider:queued", s.incCounterHandler("mojang_textures.usernames.queued"))
	d.Subscribe("mojang_textures:batch_uuids_provider:round", func(usernames []string, queueSize int) {
		s.UpdateGauge("mojang_textures.usernames.iteration_size", int64(len(usernames)))
		s.UpdateGauge("mojang_textures.usernames.queue_size", int64(queueSize))
		if len(usernames) != 0 {
			s.startTimeRecording("batch_uuids_provider_round_time_" + strings.Join(usernames, "|"))
		}
	})
	d.Subscribe("mojang_textures:batch_uuids_provider:result", func(usernames []string, profiles []*mojang.ProfileInfo, err error) {
		s.finalizeTimeRecording("batch_uuids_provider_round_time_"+strings.Join(usernames, "|"), "mojang_textures.usernames.round_time")
	})
}

func (s *StatsReporter) handleBeforeRequest(req *http.Request) {
	var key string
	m := req.Method
	p := req.URL.Path
	if p == "/skins" {
		key = "skins.get_request"
	} else if strings.HasPrefix(p, "/skins/") {
		key = "skins.request"
	} else if p == "/cloaks" {
		key = "capes.get_request"
	} else if strings.HasPrefix(p, "/cloaks/") {
		key = "capes.request"
	} else if strings.HasPrefix(p, "/textures/signed/") {
		key = "signed_textures.request"
	} else if strings.HasPrefix(p, "/textures/") {
		key = "textures.request"
	} else if strings.HasPrefix(p, "/profile/") {
		key = "profiles.request"
	} else if m == http.MethodPost && p == "/api/skins" {
		key = "api.skins.post.request"
	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") {
		key = "api.skins.delete.request"
	} else {
		return
	}

	s.IncCounter(key, 1)
}

func (s *StatsReporter) handleAfterRequest(req *http.Request, code int) {
	var key string
	m := req.Method
	p := req.URL.Path
	if m == http.MethodPost && p == "/api/skins" && code == http.StatusCreated {
		key = "api.skins.post.success"
	} else if m == http.MethodPost && p == "/api/skins" && code == http.StatusBadRequest {
		key = "api.skins.post.validation_failed"
	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNoContent {
		key = "api.skins.delete.success"
	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNotFound {
		key = "api.skins.delete.not_found"
	} else {
		return
	}

	s.IncCounter(key, 1)
}

func (s *StatsReporter) incCounterHandler(name string) func(...interface{}) {
	return func(...interface{}) {
		s.IncCounter(name, 1)
	}
}

func (s *StatsReporter) startTimeRecording(timeKey string) {
	s.timersMutex.Lock()
	defer s.timersMutex.Unlock()
	s.timersMap[timeKey] = time.Now()
}

func (s *StatsReporter) finalizeTimeRecording(timeKey string, statName string) {
	s.timersMutex.Lock()
	defer s.timersMutex.Unlock()
	startedAt, ok := s.timersMap[timeKey]
	if !ok {
		return
	}

	delete(s.timersMap, timeKey)

	s.RecordTimer(statName, time.Since(startedAt))
}

type RedisPoolCheckable interface {
	Avail() int
}

func AvailableRedisPoolSizeReporter(pool RedisPoolCheckable, d time.Duration, stop context.Context) ReporterFunc {
	return func(reporter slf.StatsReporter) {
		go func() {
			ticker := time.NewTicker(d)
			for {
				select {
				case <-stop.Done():
					ticker.Stop()
					return
				case <-ticker.C:
					reporter.UpdateGauge("redis.pool.available", int64(pool.Avail()))
				}
			}
		}()
	}
}