Cleanup metrics and add Airdroper balance metric poller

Author: jeffyanta

pkg/code/async/account/config.go

@@ -1,12 +1,19 @@
 package async_account
 
-// todo: setup configs
+import (
+	"github.com/code-payments/code-server/pkg/config"
+	"github.com/code-payments/code-server/pkg/config/env"
+)
 
 const (
 	envConfigPrefix = "ACCOUNT_SERVICE_"
+
+	AirdropperOwnerPublicKeyEnvName = envConfigPrefix + "AIRDROPPER_OWNER_PUBLIC_KEY"
+	defaultAirdropperOwnerPublicKey = "invalid" // Ensure something valid is set
 )
 
 type conf struct {
+	airdropperOwnerPublicKey config.String
 }
 
 // ConfigProvider defines how config values are pulled
@@ -15,6 +22,8 @@ type ConfigProvider func() *conf
 // WithEnvConfigs returns configuration pulled from environment variables
 func WithEnvConfigs() ConfigProvider {
 	return func() *conf {
-		return &conf{}
+		return &conf{
+			airdropperOwnerPublicKey: env.NewStringConfig(AirdropperOwnerPublicKeyEnvName, defaultAirdropperOwnerPublicKey),
+		}
 	}
 }

pkg/code/async/account/metrics.go

@@ -4,12 +4,15 @@ import (
 	"context"
 	"time"
 
+	"github.com/code-payments/code-server/pkg/code/balance"
 	"github.com/code-payments/code-server/pkg/metrics"
 )
 
 const (
 	giftCardWorkerEventName  = "GiftCardWorkerPollingCheck"
 	swapRetryWorkerEventName = "SwapRetryWorkerPollingCheck"
+
+	airdropperBalanceEventName = "AirdropperBalance"
 )
 
 func (p *service) metricsGaugeWorker(ctx context.Context) error {
@@ -23,6 +26,7 @@ func (p *service) metricsGaugeWorker(ctx context.Context) error {
 			start := time.Now()
 
 			p.recordBackupQueueStatusPollingEvent(ctx)
+			p.recordAidropAccountBalance(ctx)
 
 			delay = time.Second - time.Since(start)
 		}
@@ -36,11 +40,18 @@ func (p *service) recordBackupQueueStatusPollingEvent(ctx context.Context) {
 			"queue_size": count,
 		})
 	}
+}
 
-	count, err = p.data.GetAccountInfoCountRequiringSwapRetry(ctx)
+func (p *service) recordAidropAccountBalance(ctx context.Context) {
+	if p.airdropper == nil {
+		return
+	}
+
+	quarks, err := balance.CalculateFromCache(ctx, p.data, p.airdropper.Vault)
 	if err == nil {
-		metrics.RecordEvent(ctx, swapRetryWorkerEventName, map[string]interface{}{
-			"queue_size": count,
+		metrics.RecordEvent(ctx, airdropperBalanceEventName, map[string]interface{}{
+			"owner":   p.airdropper.VaultOwner.PublicKey().ToBase58(),
+			"balance": quarks,
 		})
 	}
 }

pkg/code/async/account/service.go

@@ -7,21 +7,33 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"github.com/code-payments/code-server/pkg/code/async"
+	"github.com/code-payments/code-server/pkg/code/common"
 	code_data "github.com/code-payments/code-server/pkg/code/data"
 )
 
 type service struct {
 	log  *logrus.Entry
 	conf *conf
 	data code_data.Provider
+
+	airdropper *common.TimelockAccounts
 }
 
 func New(data code_data.Provider, configProvider ConfigProvider) async.Service {
-	return &service{
+	ctx := context.Background()
+
+	p := &service{
 		log:  logrus.StandardLogger().WithField("service", "account"),
 		conf: configProvider(),
 		data: data,
 	}
+
+	airdropper := p.conf.airdropperOwnerPublicKey.Get(ctx)
+	if len(airdropper) > 0 && airdropper != defaultAirdropperOwnerPublicKey {
+		p.mustLoadAirdropper(ctx)
+	}
+
+	return p
 }
 
 func (p *service) Start(ctx context.Context, interval time.Duration) error {
@@ -33,16 +45,6 @@ func (p *service) Start(ctx context.Context, interval time.Duration) error {
 		}
 	}()
 
-	// todo: the open code protocol needs to get the push token from the implementing app
-	/*
-		go func() {
-			err := p.swapRetryWorker(ctx, interval)
-			if err != nil && err != context.Canceled {
-				p.log.WithError(err).Warn("swap retry processing loop terminated unexpectedly")
-			}
-		}()
-	*/
-
 	go func() {
 		err := p.metricsGaugeWorker(ctx)
 		if err != nil && err != context.Canceled {
@@ -55,3 +57,33 @@ func (p *service) Start(ctx context.Context, interval time.Duration) error {
 		return ctx.Err()
 	}
 }
+
+func (p *service) mustLoadAirdropper(ctx context.Context) {
+	log := p.log.WithFields(logrus.Fields{
+		"method": "mustLoadAirdropper",
+		"key":    p.conf.airdropperOwnerPublicKey.Get(ctx),
+	})
+
+	err := func() error {
+		vaultRecord, err := p.data.GetKey(ctx, p.conf.airdropperOwnerPublicKey.Get(ctx))
+		if err != nil {
+			return err
+		}
+
+		ownerAccount, err := common.NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+		if err != nil {
+			return err
+		}
+
+		timelockAccounts, err := ownerAccount.GetTimelockAccounts(common.CodeVmAccount, common.CoreMintAccount)
+		if err != nil {
+			return err
+		}
+
+		p.airdropper = timelockAccounts
+		return nil
+	}()
+	if err != nil {
+		log.WithError(err).Fatal("failure loading account")
+	}
+}

pkg/code/server/transaction/metrics.go

@@ -13,10 +13,11 @@ import (
 
 const (
 	userIntentCreatedEventName            = "UserIntentCreated"
-	privateUpgradeEventName               = "PrivateTransferUpgraded"
 	submitIntentLatencyBreakdownEventName = "SubmitIntentLatencyBreakdown"
-	airdropEventName                      = "Airdrop"
-	buyModulePurchaseInitiatedEventName   = "BuyModulePurchaseInitiated"
+
+	airdropEventName = "Airdrop"
+
+	buyModulePurchaseInitiatedEventName = "BuyModulePurchaseInitiated"
 )
 
 func recordUserIntentCreatedEvent(ctx context.Context, intentRecord *intent.Record) {
@@ -26,15 +27,6 @@ func recordUserIntentCreatedEvent(ctx context.Context, intentRecord *intent.Reco
 	})
 }
 
-func recordPrivacyUpgradedEvent(ctx context.Context, intentRecord *intent.Record, numUpgraded int) {
-	upgradeTimeInMs := time.Since(intentRecord.CreatedAt) / time.Millisecond
-	metrics.RecordEvent(ctx, privateUpgradeEventName, map[string]interface{}{
-		"intent":             intentRecord.IntentId,
-		"num_upgraded":       numUpgraded,
-		"time_to_upgrade_ms": int(upgradeTimeInMs),
-	})
-}
-
 func recordSubmitIntentLatencyBreakdownEvent(ctx context.Context, section string, latency time.Duration, actionCount int, intentType string) {
 	latencyInMs := latency / time.Millisecond
 	metrics.RecordEvent(ctx, submitIntentLatencyBreakdownEventName, map[string]interface{}{