commit 5c8b5c1ffdcc8b1be5673e24b2e5680f9e2e456c · veryroundbird.house/core

+1

appview/config.go

···

       17
       17
        
       	CamoSharedSecret   string `env:"TANGLED_CAMO_SHARED_SECRET"`

     

       18
       18
        
       	AvatarSharedSecret string `env:"TANGLED_AVATAR_SHARED_SECRET"`

     

       19
       19
        
       	AvatarHost         string `env:"TANGLED_AVATAR_HOST, default=https://avatar.tangled.sh"`

     

       20
       20
       +
       	EnableTelemetry    bool   `env:"TANGLED_TELEMETRY_ENABLED, default=false"`

     

       20
       21
        
       }

     

       21
       22
        
       

     

       22
       23
        
       func LoadConfig(ctx context.Context) (*Config, error) {

+6 -1

appview/state/router.go

···

       13
       13
        
       func (s *State) Router() http.Handler {

     

       14
       14
        
       	router := chi.NewRouter()

     

       15
       15
        
       

     

       16
       16
       +
       	if s.t != nil {

     

       17
       17
       +
       		// top-level telemetry middleware

     

       18
       18
       +
       		// router.Use(s.t.RequestDuration())

     

       19
       19
       +
       		// router.Use(s.t.RequestInFlight())

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       16
       22
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

       17
       23
        
       		pat := chi.URLParam(r, "*")

     

       18
       24
        
       		if strings.HasPrefix(pat, "did:") || strings.HasPrefix(pat, "@") {

     
···

       48
       54
        
       

     

       49
       55
        
       func (s *State) UserRouter() http.Handler {

     

       50
       56
        
       	r := chi.NewRouter()

     

       51
       51
       -
       

     

       52
       57
        
       	// strip @ from user

     

       53
       58
        
       	r.Use(StripLeadingAt)

     

       54
       59

+21 -1

appview/state/state.go

···

       9
       9
        
       	"log"

     

       10
       10
        
       	"log/slog"

     

       11
       11
        
       	"net/http"

     

       12
       12
       +
       	"runtime/debug"

     

       12
       13
        
       	"strings"

     

       13
       14
        
       	"time"

     

       14
       15
        
       

     
···

       24
       25
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       25
       26
        
       	"tangled.sh/tangled.sh/core/jetstream"

     

       26
       27
        
       	"tangled.sh/tangled.sh/core/rbac"

     

       28
       28
       +
       	"tangled.sh/tangled.sh/core/telemetry"

     

       27
       29
        
       )

     

       28
       30
        
       

     

       29
       31
        
       type State struct {

     
···

       34
       36
        
       	pages    *pages.Pages

     

       35
       37
        
       	resolver *appview.Resolver

     

       36
       38
        
       	jc       *jetstream.JetstreamClient

     

       39
       39
       +
       	t        *telemetry.Telemetry

     

       37
       40
        
       	config   *appview.Config

     

       38
       41
        
       }

     

       39
       42
        
       

     

       40
       40
       -
       func Make(config *appview.Config) (*State, error) {

     

       43
       43
       +
       func Make(ctx context.Context, config *appview.Config) (*State, error) {

     

       41
       44
        
       	d, err := db.Make(config.DbPath)

     

       42
       45
        
       	if err != nil {

     

       43
       46
        
       		return nil, err

     
···

       59
       62
        
       

     

       60
       63
        
       	resolver := appview.NewResolver()

     

       61
       64
        
       

     

       65
       65
       +
       	bi, ok := debug.ReadBuildInfo()

     

       66
       66
       +
       	var version string

     

       67
       67
       +
       	if ok {

     

       68
       68
       +
       		version = bi.Main.Version

     

       69
       69
       +
       	} else {

     

       70
       70
       +
       		version = "v0.0.0-unknown"

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       62
       73
        
       	wrapper := db.DbWrapper{d}

     

       63
       74
        
       	jc, err := jetstream.NewJetstreamClient(

     

       64
       75
        
       		config.JetstreamEndpoint,

     
···

       77
       88
        
       		return nil, fmt.Errorf("failed to start jetstream watcher: %w", err)

     

       78
       89
        
       	}

     

       79
       90
        
       

     

       91
       91
       +
       	var tele *telemetry.Telemetry

     

       92
       92
       +
       	if config.EnableTelemetry {

     

       93
       93
       +
       		tele, err = telemetry.NewTelemetry(ctx, "appview", version, config.Dev)

     

       94
       94
       +
       		if err != nil {

     

       95
       95
       +
       			return nil, fmt.Errorf("failed to setup telemetry: %w", err)

     

       96
       96
       +
       		}

     

       97
       97
       +
       	}

     

       98
       98
       +
       

     

       80
       99
        
       	state := &State{

     

       81
       100
        
       		d,

     

       82
       101
        
       		auth,

     
···

       85
       104
        
       		pgs,

     

       86
       105
        
       		resolver,

     

       87
       106
        
       		jc,

     

       107
       107
       +
       		tele,

     

       88
       108
        
       		config,

     

       89
       109
        
       	}

     

       90
       110

+4 -2

cmd/appview/main.go

···

       14
       14
        
       func main() {

     

       15
       15
        
       	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, nil)))

     

       16
       16
        
       

     

       17
       17
       -
       	c, err := appview.LoadConfig(context.Background())

     

       17
       17
       +
       	ctx := context.Background()

     

       18
       18
       +
       

     

       19
       19
       +
       	c, err := appview.LoadConfig(ctx)

     

       18
       20
        
       	if err != nil {

     

       19
       21
        
       		log.Println("failed to load config", "error", err)

     

       20
       22
        
       		return

     

       21
       23
        
       	}

     

       22
       24
        
       

     

       23
       23
       -
       	state, err := state.Make(c)

     

       25
       25
       +
       	state, err := state.Make(ctx, c)

     

       24
       26
        
       

     

       25
       27
        
       	if err != nil {

     

       26
       28
        
       		log.Fatal(err)