commit 9d30365335911789ab100624e933ec40d8586172 · veryroundbird.house/core

+6

appview/config.go

···

       36
       36
        
       	SharedSecret string `env:"SHARED_SECRET"`

     

       37
       37
        
       }

     

       38
       38
        
       

     

       39
       39
       +
       type PosthogConfig struct {

     

       40
       40
       +
       	ApiKey   string `env:"API_KEY"`

     

       41
       41
       +
       	Endpoint string `env:"ENDPOINT, default=https://eu.i.posthog.com"`

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       39
       44
        
       type Config struct {

     

       40
       45
        
       	Core      CoreConfig      `env:",prefix=TANGLED_"`

     

       41
       46
        
       	Jetstream JetstreamConfig `env:",prefix=TANGLED_JETSTREAM_"`

     

       42
       47
        
       	Resend    ResendConfig    `env:",prefix=TANGLED_RESEND_"`

     

       48
       48
       +
       	Posthog   PosthogConfig   `env:",prefix=TANGLED_POSTHOG_"`

     

       43
       49
        
       	Camo      CamoConfig      `env:",prefix=TANGLED_CAMO_"`

     

       44
       50
        
       	Avatar    AvatarConfig    `env:",prefix=TANGLED_AVATAR_"`

     

       45
       51
        
       	OAuth     OAuthConfig     `env:",prefix=TANGLED_OAUTH_"`

+12

appview/oauth/handler/handler.go

···

       12
       12
        
       	"github.com/gorilla/sessions"

     

       13
       13
        
       	"github.com/haileyok/atproto-oauth-golang/helpers"

     

       14
       14
        
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       15
       15
       +
       	"github.com/posthog/posthog-go"

     

       15
       16
        
       	"tangled.sh/tangled.sh/core/appview"

     

       16
       17
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       17
       18
        
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     
···

       34
       35
        
       	Store    *sessions.CookieStore

     

       35
       36
        
       	OAuth    *oauth.OAuth

     

       36
       37
        
       	Enforcer *rbac.Enforcer

     

       38
       38
       +
       	Posthog  posthog.Client

     

       37
       39
        
       }

     

       38
       40
        
       

     

       39
       41
        
       func (o *OAuthHandler) Router() http.Handler {

     
···

       247
       249
        
       

     

       248
       250
        
       	log.Println("session saved successfully")

     

       249
       251
        
       	go o.addToDefaultKnot(oauthRequest.Did)

     

       252
       252
       +
       

     

       253
       253
       +
       	if !o.Config.Core.Dev {

     

       254
       254
       +
       		err = o.Posthog.Enqueue(posthog.Capture{

     

       255
       255
       +
       			DistinctId: oauthRequest.Did,

     

       256
       256
       +
       			Event:      "signin",

     

       257
       257
       +
       		})

     

       258
       258
       +
       		if err != nil {

     

       259
       259
       +
       			log.Println("failed to enqueue posthog event:", err)

     

       260
       260
       +
       		}

     

       261
       261
       +
       	}

     

       250
       262
        
       

     

       251
       263
        
       	http.Redirect(w, r, "/", http.StatusFound)

     

       252
       264
        
       }

+23

appview/state/follow.go

···

       7
       7
        
       

     

       8
       8
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       9
       9
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       10
       10
       +
       	"github.com/posthog/posthog-go"

     

       10
       11
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       11
       12
        
       	"tangled.sh/tangled.sh/core/appview"

     

       12
       13
        
       	"tangled.sh/tangled.sh/core/appview/db"

     
···

       70
       71
        
       			FollowStatus: db.IsFollowing,

     

       71
       72
        
       		})

     

       72
       73
        
       

     

       74
       74
       +
       		if !s.config.Core.Dev {

     

       75
       75
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       76
       76
       +
       				DistinctId: currentUser.Did,

     

       77
       77
       +
       				Event:      "follow",

     

       78
       78
       +
       				Properties: posthog.Properties{"subject": subjectIdent.DID.String()},

     

       79
       79
       +
       			})

     

       80
       80
       +
       			if err != nil {

     

       81
       81
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       82
       82
       +
       			}

     

       83
       83
       +
       		}

     

       84
       84
       +
       

     

       73
       85
        
       		return

     

       74
       86
        
       	case http.MethodDelete:

     

       75
       87
        
       		// find the record in the db

     
···

       100
       112
        
       			UserDid:      subjectIdent.DID.String(),

     

       101
       113
        
       			FollowStatus: db.IsNotFollowing,

     

       102
       114
        
       		})

     

       115
       115
       +
       

     

       116
       116
       +
       		if !s.config.Core.Dev {

     

       117
       117
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       118
       118
       +
       				DistinctId: currentUser.Did,

     

       119
       119
       +
       				Event:      "unfollow",

     

       120
       120
       +
       				Properties: posthog.Properties{"subject": subjectIdent.DID.String()},

     

       121
       121
       +
       			})

     

       122
       122
       +
       			if err != nil {

     

       123
       123
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       124
       124
       +
       			}

     

       125
       125
       +
       		}

     

       103
       126
        
       

     

       104
       127
        
       		return

     

       105
       128
        
       	}

+11

appview/state/profile.go

···

       15
       15
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       16
       16
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       17
       17
        
       	"github.com/go-chi/chi/v5"

     

       18
       18
       +
       	"github.com/posthog/posthog-go"

     

       18
       19
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     
···

       345
       346
        
       		log.Println("failed to update profile", err)

     

       346
       347
        
       		s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")

     

       347
       348
        
       		return

     

       349
       349
       +
       	}

     

       350
       350
       +
       

     

       351
       351
       +
       	if !s.config.Core.Dev {

     

       352
       352
       +
       		err = s.posthog.Enqueue(posthog.Capture{

     

       353
       353
       +
       			DistinctId: user.Did,

     

       354
       354
       +
       			Event:      "edit_profile",

     

       355
       355
       +
       		})

     

       356
       356
       +
       		if err != nil {

     

       357
       357
       +
       			log.Println("failed to enqueue posthog event:", err)

     

       358
       358
       +
       		}

     

       348
       359
        
       	}

     

       349
       360
        
       

     

       350
       361
        
       	s.pages.HxRedirect(w, "/"+user.Did)

+23

appview/state/pull.go

···

       28
       28
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       29
       29
        
       	"github.com/go-chi/chi/v5"

     

       30
       30
        
       	"github.com/google/uuid"

     

       31
       31
       +
       	"github.com/posthog/posthog-go"

     

       31
       32
        
       )

     

       32
       33
        
       

     

       33
       34
        
       // htmx fragment

     
···

       605
       606
        
       			return

     

       606
       607
        
       		}

     

       607
       608
        
       

     

       609
       609
       +
       		if !s.config.Core.Dev {

     

       610
       610
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       611
       611
       +
       				DistinctId: user.Did,

     

       612
       612
       +
       				Event:      "new_pull_comment",

     

       613
       613
       +
       				Properties: posthog.Properties{"repo_at": f.RepoAt.String(), "pull_id": pull.PullId},

     

       614
       614
       +
       			})

     

       615
       615
       +
       			if err != nil {

     

       616
       616
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       617
       617
       +
       			}

     

       618
       618
       +
       		}

     

       619
       619
       +
       

     

       608
       620
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

     

       609
       621
        
       		return

     

       610
       622
        
       	}

     
···

       980
       992
        
       		log.Println("failed to create pull request", err)

     

       981
       993
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       982
       994
        
       		return

     

       995
       995
       +
       	}

     

       996
       996
       +
       

     

       997
       997
       +
       	if !s.config.Core.Dev {

     

       998
       998
       +
       		err = s.posthog.Enqueue(posthog.Capture{

     

       999
       999
       +
       			DistinctId: user.Did,

     

       1000
       1000
       +
       			Event:      "new_pull",

     

       1001
       1001
       +
       			Properties: posthog.Properties{"repo_at": f.RepoAt.String(), "pull_id": pullId},

     

       1002
       1002
       +
       		})

     

       1003
       1003
       +
       		if err != nil {

     

       1004
       1004
       +
       			log.Println("failed to enqueue posthog event:", err)

     

       1005
       1005
       +
       		}

     

       983
       1006
        
       	}

     

       984
       1007
        
       

     

       985
       1008
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))

+12

appview/state/repo.go

···

       33
       33
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       34
       34
        
       	"github.com/go-chi/chi/v5"

     

       35
       35
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       36
       36
       +
       	"github.com/posthog/posthog-go"

     

       36
       37
        
       

     

       37
       38
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       38
       39
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     
···

       1875
       1876
        
       			log.Println("failed to set issue at", err)

     

       1876
       1877
        
       			s.pages.Notice(w, "issues", "Failed to create issue.")

     

       1877
       1878
        
       			return

     

       1879
       1879
       +
       		}

     

       1880
       1880
       +
       

     

       1881
       1881
       +
       		if !s.config.Core.Dev {

     

       1882
       1882
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       1883
       1883
       +
       				DistinctId: user.Did,

     

       1884
       1884
       +
       				Event:      "new_issue",

     

       1885
       1885
       +
       				Properties: posthog.Properties{"repo_at": f.RepoAt.String(), "issue_id": issueId},

     

       1886
       1886
       +
       			})

     

       1887
       1887
       +
       			if err != nil {

     

       1888
       1888
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       1889
       1889
       +
       			}

     

       1878
       1890
        
       		}

     

       1879
       1891
        
       

     

       1880
       1892
        
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issueId))

+1

appview/state/router.go

···

       269
       269
        
       		Store:    sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),

     

       270
       270
        
       		OAuth:    s.oauth,

     

       271
       271
        
       		Enforcer: s.enforcer,

     

       272
       272
       +
       		Posthog:  s.posthog,

     

       272
       273
        
       	}

     

       273
       274
        
       

     

       274
       275
        
       	return oauth.Router()

+23

appview/state/star.go

···

       8
       8
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       9
       9
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
       10
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       11
       11
       +
       	"github.com/posthog/posthog-go"

     

       11
       12
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       12
       13
        
       	"tangled.sh/tangled.sh/core/appview"

     

       13
       14
        
       	"tangled.sh/tangled.sh/core/appview/db"

     
···

       75
       76
        
       			},

     

       76
       77
        
       		})

     

       77
       78
        
       

     

       79
       79
       +
       		if !s.config.Core.Dev {

     

       80
       80
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       81
       81
       +
       				DistinctId: currentUser.Did,

     

       82
       82
       +
       				Event:      "star",

     

       83
       83
       +
       				Properties: posthog.Properties{"repo_at": subjectUri.String()},

     

       84
       84
       +
       			})

     

       85
       85
       +
       			if err != nil {

     

       86
       86
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       87
       87
       +
       			}

     

       88
       88
       +
       		}

     

       89
       89
       +
       

     

       78
       90
        
       		return

     

       79
       91
        
       	case http.MethodDelete:

     

       80
       92
        
       		// find the record in the db

     
···

       114
       126
        
       				StarCount: starCount,

     

       115
       127
        
       			},

     

       116
       128
        
       		})

     

       129
       129
       +
       

     

       130
       130
       +
       		if !s.config.Core.Dev {

     

       131
       131
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       132
       132
       +
       				DistinctId: currentUser.Did,

     

       133
       133
       +
       				Event:      "unstar",

     

       134
       134
       +
       				Properties: posthog.Properties{"repo_at": subjectUri.String()},

     

       135
       135
       +
       			})

     

       136
       136
       +
       			if err != nil {

     

       137
       137
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       138
       138
       +
       			}

     

       139
       139
       +
       		}

     

       117
       140
        
       

     

       118
       141
        
       		return

     

       119
       142
        
       	}

+19 -76

appview/state/state.go

···

       17
       17
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       18
       18
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       19
       19
        
       	"github.com/go-chi/chi/v5"

     

       20
       20
       +
       	"github.com/posthog/posthog-go"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       21
       22
        
       	"tangled.sh/tangled.sh/core/appview"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/appview/db"

     
···

       34
       35
        
       	tidClock syntax.TIDClock

     

       35
       36
        
       	pages    *pages.Pages

     

       36
       37
        
       	resolver *appview.Resolver

     

       38
       38
       +
       	posthog  posthog.Client

     

       37
       39
        
       	jc       *jetstream.JetstreamClient

     

       38
       40
        
       	config   *appview.Config

     

       39
       41
        
       }

     
···

       57
       59
        
       

     

       58
       60
        
       	oauth := oauth.NewOAuth(d, config)

     

       59
       61
        
       

     

       62
       62
       +
       	posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})

     

       63
       63
       +
       	if err != nil {

     

       64
       64
       +
       		return nil, fmt.Errorf("failed to create posthog client: %w", err)

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       60
       67
        
       	wrapper := db.DbWrapper{d}

     

       61
       68
        
       	jc, err := jetstream.NewJetstreamClient(

     

       62
       69
        
       		config.Jetstream.Endpoint,

     
···

       88
       95
        
       		clock,

     

       89
       96
        
       		pgs,

     

       90
       97
        
       		resolver,

     

       98
       98
       +
       		posthog,

     

       91
       99
        
       		jc,

     

       92
       100
        
       		config,

     

       93
       101
        
       	}

     
···

       98
       106
        
       func TID(c *syntax.TIDClock) string {

     

       99
       107
        
       	return c.Next().String()

     

       100
       108
        
       }

     

       101
       101
       -
       

     

       102
       102
       -
       // func (s *State) Login(w http.ResponseWriter, r *http.Request) {

     

       103
       103
       -
       // 	ctx := r.Context()

     

       104
       104
       -
       

     

       105
       105
       -
       // 	switch r.Method {

     

       106
       106
       -
       // 	case http.MethodGet:

     

       107
       107
       -
       // 		err := s.pages.Login(w, pages.LoginParams{})

     

       108
       108
       -
       // 		if err != nil {

     

       109
       109
       -
       // 			log.Printf("rendering login page: %s", err)

     

       110
       110
       -
       // 		}

     

       111
       111
       -
       

     

       112
       112
       -
       // 		return

     

       113
       113
       -
       // 	case http.MethodPost:

     

       114
       114
       -
       // 		handle := strings.TrimPrefix(r.FormValue("handle"), "@")

     

       115
       115
       -
       // 		appPassword := r.FormValue("app_password")

     

       116
       116
       -
       

     

       117
       117
       -
       // 		resolved, err := s.resolver.ResolveIdent(ctx, handle)

     

       118
       118
       -
       // 		if err != nil {

     

       119
       119
       -
       // 			log.Println("failed to resolve handle:", err)

     

       120
       120
       -
       // 			s.pages.Notice(w, "login-msg", fmt.Sprintf("\"%s\" is an invalid handle.", handle))

     

       121
       121
       -
       // 			return

     

       122
       122
       -
       // 		}

     

       123
       123
       -
       

     

       124
       124
       -
       // 		atSession, err := s.oauth.CreateInitialSession(ctx, resolved, appPassword)

     

       125
       125
       -
       // 		if err != nil {

     

       126
       126
       -
       // 			s.pages.Notice(w, "login-msg", "Invalid handle or password.")

     

       127
       127
       -
       // 			return

     

       128
       128
       -
       // 		}

     

       129
       129
       -
       // 		sessionish := auth.CreateSessionWrapper{ServerCreateSession_Output: atSession}

     

       130
       130
       -
       

     

       131
       131
       -
       // 		err = s.oauth.StoreSession(r, w, &sessionish, resolved.PDSEndpoint())

     

       132
       132
       -
       // 		if err != nil {

     

       133
       133
       -
       // 			s.pages.Notice(w, "login-msg", "Failed to login, try again later.")

     

       134
       134
       -
       // 			return

     

       135
       135
       -
       // 		}

     

       136
       136
       -
       

     

       137
       137
       -
       // 		log.Printf("successfully saved session for %s (%s)", atSession.Handle, atSession.Did)

     

       138
       138
       -
       

     

       139
       139
       -
       // 		did := resolved.DID.String()

     

       140
       140
       -
       // 		defaultKnot := "knot1.tangled.sh"

     

       141
       141
       -
       

     

       142
       142
       -
       // 		go func() {

     

       143
       143
       -
       // 			log.Printf("adding %s to default knot", did)

     

       144
       144
       -
       // 			err = s.enforcer.AddMember(defaultKnot, did)

     

       145
       145
       -
       // 			if err != nil {

     

       146
       146
       -
       // 				log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       147
       147
       -
       // 				return

     

       148
       148
       -
       // 			}

     

       149
       149
       -
       // 			err = s.enforcer.E.SavePolicy()

     

       150
       150
       -
       // 			if err != nil {

     

       151
       151
       -
       // 				log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       152
       152
       -
       // 				return

     

       153
       153
       -
       // 			}

     

       154
       154
       -
       

     

       155
       155
       -
       // 			secret, err := db.GetRegistrationKey(s.db, defaultKnot)

     

       156
       156
       -
       // 			if err != nil {

     

       157
       157
       -
       // 				log.Println("failed to get registration key for knot1.tangled.sh")

     

       158
       158
       -
       // 				return

     

       159
       159
       -
       // 			}

     

       160
       160
       -
       // 			signedClient, err := NewSignedClient(defaultKnot, secret, s.config.Core.Dev)

     

       161
       161
       -
       // 			resp, err := signedClient.AddMember(did)

     

       162
       162
       -
       // 			if err != nil {

     

       163
       163
       -
       // 				log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       164
       164
       -
       // 				return

     

       165
       165
       -
       // 			}

     

       166
       166
       -
       

     

       167
       167
       -
       // 			if resp.StatusCode != http.StatusNoContent {

     

       168
       168
       -
       // 				log.Println("failed to add user to knot1.tangled.sh: ", resp.StatusCode)

     

       169
       169
       -
       // 				return

     

       170
       170
       -
       // 			}

     

       171
       171
       -
       // 		}()

     

       172
       172
       -
       

     

       173
       173
       -
       // 		s.pages.HxRedirect(w, "/")

     

       174
       174
       -
       // 		return

     

       175
       175
       -
       // 	}

     

       176
       176
       -
       // }

     

       177
       109
        
       

     

       178
       110
        
       func (s *State) Logout(w http.ResponseWriter, r *http.Request) {

     

       179
       111
        
       	s.oauth.ClearSession(r, w)

     
···

       773
       705
        
       			log.Println("failed to update ACLs", err)

     

       774
       706
        
       			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       775
       707
        
       			return

     

       708
       708
       +
       		}

     

       709
       709
       +
       

     

       710
       710
       +
       		if !s.config.Core.Dev {

     

       711
       711
       +
       			err = s.posthog.Enqueue(posthog.Capture{

     

       712
       712
       +
       				DistinctId: user.Did,

     

       713
       713
       +
       				Event:      "new_repo",

     

       714
       714
       +
       				Properties: posthog.Properties{"repo": repoName, "repo_at": repo.AtUri},

     

       715
       715
       +
       			})

     

       716
       716
       +
       			if err != nil {

     

       717
       717
       +
       				log.Println("failed to enqueue posthog event:", err)

     

       718
       718
       +
       			}

     

       776
       719
        
       		}

     

       777
       720
        
       

     

       778
       721
        
       		s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s", user.Handle, repoName))

+1

go.mod

···

       24
       24
        
       	github.com/lestrrat-go/jwx/v2 v2.0.12

     

       25
       25
        
       	github.com/mattn/go-sqlite3 v1.14.24

     

       26
       26
        
       	github.com/microcosm-cc/bluemonday v1.0.27

     

       27
       27
       +
       	github.com/posthog/posthog-go v1.5.5

     

       27
       28
        
       	github.com/resend/resend-go/v2 v2.15.0

     

       28
       29
        
       	github.com/sethvargo/go-envconfig v1.1.0

     

       29
       30
        
       	github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e

+2

go.sum

···

       224
       224
        
       github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       225
       225
        
       github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f h1:VXTQfuJj9vKR4TCkEuWIckKvdHFeJH/huIFJ9/cXOB0=

     

       226
       226
        
       github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f/go.mod h1:/zvteZs/GwLtCgZ4BL6CBsk9IKIlexP43ObX9AxTqTw=

     

       227
       227
       +
       github.com/posthog/posthog-go v1.5.5 h1:2o3j7IrHbTIfxRtj4MPaXKeimuTYg49onNzNBZbwksM=

     

       228
       228
       +
       github.com/posthog/posthog-go v1.5.5/go.mod h1:3RqUmSnPuwmeVj/GYrS75wNGqcAKdpODiwc83xZWgdE=

     

       227
       229
        
       github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=

     

       228
       230
        
       github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=

     

       229
       231
        
       github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=