appview: state: setup metrics middleware

appview/config.go

···
 	CamoSharedSecret   string `env:"TANGLED_CAMO_SHARED_SECRET"`
 	AvatarSharedSecret string `env:"TANGLED_AVATAR_SHARED_SECRET"`
 	AvatarHost         string `env:"TANGLED_AVATAR_HOST, default=https://avatar.tangled.sh"`
+	EnableTelemetry    bool   `env:"TANGLED_TELEMETRY_ENABLED, default=false"`
 }
 
 func LoadConfig(ctx context.Context) (*Config, error) {

appview/state/router.go

···
 func (s *State) Router() http.Handler {
 	router := chi.NewRouter()
 
+	if s.t != nil {
+		// top-level telemetry middleware
+		// router.Use(s.t.RequestDuration())
+		// router.Use(s.t.RequestInFlight())
+	}
+
 	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {
 		pat := chi.URLParam(r, "*")
 		if strings.HasPrefix(pat, "did:") || strings.HasPrefix(pat, "@") {
···
 
 func (s *State) UserRouter() http.Handler {
 	r := chi.NewRouter()
-
 	// strip @ from user
 	r.Use(StripLeadingAt)
 

appview/state/state.go

···
 	"log"
 	"log/slog"
 	"net/http"
+	"runtime/debug"
 	"strings"
 	"time"
 
···
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/jetstream"
 	"tangled.sh/tangled.sh/core/rbac"
+	"tangled.sh/tangled.sh/core/telemetry"
 )
 
 type State struct {
···
 	pages    *pages.Pages
 	resolver *appview.Resolver
 	jc       *jetstream.JetstreamClient
+	t        *telemetry.Telemetry
 	config   *appview.Config
 }
 
-func Make(config *appview.Config) (*State, error) {
+func Make(ctx context.Context, config *appview.Config) (*State, error) {
 	d, err := db.Make(config.DbPath)
 	if err != nil {
 		return nil, err
···
 
 	resolver := appview.NewResolver()
 
+	bi, ok := debug.ReadBuildInfo()
+	var version string
+	if ok {
+		version = bi.Main.Version
+	} else {
+		version = "v0.0.0-unknown"
+	}
+
 	wrapper := db.DbWrapper{d}
 	jc, err := jetstream.NewJetstreamClient(
 		config.JetstreamEndpoint,
···
 		return nil, fmt.Errorf("failed to start jetstream watcher: %w", err)
 	}
 
+	var tele *telemetry.Telemetry
+	if config.EnableTelemetry {
+		tele, err = telemetry.NewTelemetry(ctx, "appview", version, config.Dev)
+		if err != nil {
+			return nil, fmt.Errorf("failed to setup telemetry: %w", err)
+		}
+	}
+
 	state := &State{
 		d,
 		auth,
···
 		pgs,
 		resolver,
 		jc,
+		tele,
 		config,
 	}
 

cmd/appview/main.go

···
 func main() {
 	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, nil)))
 
-	c, err := appview.LoadConfig(context.Background())
+	ctx := context.Background()
+
+	c, err := appview.LoadConfig(ctx)
 	if err != nil {
 		log.Println("failed to load config", "error", err)
 		return
 	}
 
-	state, err := state.Make(c)
+	state, err := state.Make(ctx, c)
 
 	if err != nil {
 		log.Fatal(err)