refactor logging (#6)

* refactor logging

* chore: update go.mod and gitignore

.gitignore

@@ -21,5 +21,6 @@
 go.work
 
 #Airdrop tool
+airdrop
 balance.json
 config.toml

cmd/airdrop/main.go

@@ -22,34 +22,39 @@ func main() {
 	// Capture start time
 	startTime := time.Now()
 
+	// Setup logger
 	logger, err := logger.Setup()
 	if err != nil {
 		log.Fatalf("Failed to initialize zap logger: %v", err)
 	}
+	defer logger.Sync() // Flushes buffer, if any
 
+	// Parse command line flags
 	configPath := flag.String("c", "configs/config.toml", "path to config file")
 	blockHeight := flag.String("h", "latest", "block height to query")
 	flag.Parse()
 
+	// Load config
 	cfg, err := config.LoadConfig(*configPath)
 	if err != nil {
 		logger.Fatal("Failed to load config", zap.Error(err))
 	}
 
+	// Determine block height
 	if *blockHeight == "latest" {
-		var err error
 		*blockHeight, err = queries.GetLatestHeight(cfg.RPCServerAddress + "/status")
 		if err != nil {
-			log.Fatal("Failed to fetch latest height", zap.Error(err))
+			logger.Fatal("Failed to fetch latest height", zap.Error(err))
 		}
 	} else {
 		if _, err := strconv.Atoi(*blockHeight); err != nil {
-			log.Fatal("Please provide the block height as an integer")
+			logger.Fatal("Please provide the block height as an integer", zap.Error(err))
 		}
 	}
 
-	logger.Info("", zap.String("Block height", *blockHeight))
+	logger.Info("Using block height", zap.String("Block height", *blockHeight))
 
+	// Setup gRPC connection
 	conn, err := utils.SetupGRPCConnection(cfg.GRPCServerAddress)
 	if err != nil {
 		logger.Fatal("Failed to connect to GRPC server", zap.Error(err))
@@ -58,15 +63,24 @@ func main() {
 
 	client := query.NewQueryClient(conn)
 
+	// Perform airdrop calculation
 	balanceInfo, err := chains.Airdrop(client.StakingClient, *configPath, *blockHeight, logger)
 	if err != nil {
 		logger.Fatal("Failed to calculate airdrop", zap.Error(err))
 	}
 
-	fileBalance, _ := json.MarshalIndent(balanceInfo, "", " ")
-	_ = os.WriteFile("balance.json", fileBalance, 0o600)
+	// Write balance info to file
+	fileBalance, err := json.MarshalIndent(balanceInfo, "", " ")
+	if err != nil {
+		logger.Fatal("Failed to marshal balance info", zap.Error(err))
+	}
+
+	err = os.WriteFile("balance.json", fileBalance, 0o600)
+	if err != nil {
+		logger.Fatal("Failed to write balance info to file", zap.Error(err))
+	}
 
-	// Calculate and print total time duration
+	// Calculate and log total time duration
 	duration := time.Since(startTime)
-	logger.Info("", zap.String("Total time taken", duration.String()))
+	logger.Info("Total time taken", zap.String("Duration", duration.String()))
 }

go.mod

@@ -105,7 +105,6 @@ require (
 	github.com/zondax/hid v0.9.2 // indirect
 	github.com/zondax/ledger-go v0.14.3 // indirect
 	go.etcd.io/bbolt v1.3.7 // indirect
-	go.uber.org/atomic v1.10.0 // indirect
 	go.uber.org/multierr v1.10.0 // indirect
 	go.uber.org/zap v1.27.0
 	golang.org/x/crypto v0.21.0 // indirect

go.sum

@@ -50,9 +50,6 @@ github.com/btcsuite/btcd/btcutil v1.1.2 h1:XLMbX8JQEiwMcYft2EGi8zPUkoa0abKIU6/BJ
 github.com/btcsuite/btcd/btcutil v1.1.2/go.mod h1:UR7dsSJzJUfMmFiiLlIrMq1lS9jh9EdCV7FStZSnpi0=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
-github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
-github.com/cenkalti/backoff/v4 v4.1.3 h1:cFAlzYUlVYDysBEH2T5hyJZMh3+5+WCBvSnK6Q8UtC4=
-github.com/cenkalti/backoff/v4 v4.1.3/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
 github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
@@ -457,11 +454,9 @@ github.com/zondax/ledger-go v0.14.3/go.mod h1:IKKaoxupuB43g4NxeQmbLXv7T9AlQyie1U
 go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
 go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
-go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
-go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
 go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
 go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=

internal/chains/airdrop.go

@@ -42,79 +42,83 @@ func Airdrop(stakingClient stakingtypes.QueryClient, configPath, blockHeight str
 	if err != nil {
 		return nil, fmt.Errorf("failed to load minimum staking tokens worth: %w", err)
 	}
-	//
 
+	// Initialize delegators slice
 	delegators := []stakingtypes.DelegationResponse{}
 
+	// Get validators
 	validators, err := queries.GetValidators(stakingClient, blockHeight)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get validators: %w", err)
 	}
-	logger.Info("", zap.Int("Total validator", len(validators)))
+	logger.Info("Fetched validators", zap.Int("totalValidators", len(validators)))
 
+	// Get delegations for each validator
 	for validatorIndex, validator := range validators {
 		delegationsResponse, err := queries.GetValidatorDelegations(stakingClient, validator.OperatorAddress, blockHeight)
 		if err != nil {
 			return nil, fmt.Errorf("failed to query delegate info for validator: %w", err)
 		}
 		total := delegationsResponse.Pagination.Total
-		logger.Info(fmt.Sprintf("Validator index: %d", validatorIndex), zap.Uint64("Total delegators", total))
+		logger.Info("Fetched delegations", zap.Int("validatorIndex", validatorIndex), zap.Uint64("totalDelegators", total))
 		delegators = append(delegators, delegationsResponse.DelegationResponses...)
 	}
 
-	usd := sdkmath.LegacyMustNewDecFromStr(minimumStakingTokensWorth)
+	// Fetch token price in USD
 	priceSourceURL := priceSource + coinID + "&vs_currencies=usd"
 	tokenPriceInUsd, err := queries.FetchTokenPrice(priceSourceURL, coinID)
-	logger.Info("", zap.String("Token price in usd", tokenPriceInUsd.String()))
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch token price: %w", err)
 	}
+	logger.Info("Fetched token price", zap.String("priceSourceURL", priceSourceURL), zap.String("tokenPriceInUSD", tokenPriceInUsd.String()))
+
+	// Calculate minimum tokens threshold
+	usd := sdkmath.LegacyMustNewDecFromStr(minimumStakingTokensWorth)
 	minimumTokensThreshold := usd.QuoTruncate(tokenPriceInUsd)
-	logger.Info("", zap.String(fmt.Sprintf("Amount tokens worth $%s:", minimumStakingTokensWorth), minimumTokensThreshold.String()))
+	logger.Info("Calculated minimum tokens threshold", zap.String("minimumStakingTokensWorth", minimumStakingTokensWorth), zap.String("minimumTokensThreshold", minimumTokensThreshold.String()))
 
-	// Caculate total delegated tokens
+	// Calculate total delegated tokens
 	totalDelegatedTokens := sdkmath.LegacyMustNewDecFromStr("0")
 	for _, delegator := range delegators {
 		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
 		validatorInfo := validators[validatorIndex]
-		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+		token := delegator.Delegation.Shares.MulInt(validatorInfo.Tokens).QuoTruncate(validatorInfo.DelegatorShares)
 		totalDelegatedTokens = totalDelegatedTokens.Add(token)
 	}
+	logger.Debug("Calculated total delegated tokens", zap.String("totalDelegatedTokens", totalDelegatedTokens.String()))
 
-	logger.Debug("", zap.String("Total delegated tokens", totalDelegatedTokens.String()))
-
+	// Calculate airdrop tokens
 	airdropTokens := sdkmath.LegacyMustNewDecFromStr(totalAirdropTokens)
-	logger.Debug("", zap.String("Total tokens for airdrop", airdropTokens.String()))
+	logger.Debug("Total tokens for airdrop", zap.String("airdropTokens", airdropTokens.String()))
 
 	airdropMap := make(map[string]int64)
 	checkAmount := int64(0)
 	balanceInfo := []banktypes.Balance{}
+
 	for _, delegator := range delegators {
 		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
 		validatorInfo := validators[validatorIndex]
-		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+		token := delegator.Delegation.Shares.MulInt(validatorInfo.Tokens).QuoTruncate(validatorInfo.DelegatorShares)
 		// Remove account staking tokens worth less than threshold
 		if token.LT(minimumTokensThreshold) {
 			continue
 		}
 
-		logger.Debug(
-			fmt.Sprintf("Delegator address: %s", delegator.Delegation.DelegatorAddress),
-			zap.String("Staking tokens", token.String()),
-		)
+		logger.Debug("Delegator staking tokens", zap.String("delegatorAddress", delegator.Delegation.DelegatorAddress), zap.String("stakingTokens", token.String()))
 
 		tokenAirdrop := airdropTokens.Mul(token).QuoTruncate(totalDelegatedTokens)
 		bech32Address, err := utils.ConvertBech32Address(delegator.Delegation.DelegatorAddress, tokenDenom)
 		if err != nil {
 			return nil, fmt.Errorf("failed to convert Bech32Address: %w", err)
 		}
 
-		logger.Debug(fmt.Sprintf("Address: %s", bech32Address), zap.String("Tokens airdrop", tokenAirdrop.String()))
+		logger.Debug("Airdrop tokens", zap.String("address", bech32Address), zap.String("tokensAirdrop", tokenAirdrop.String()))
 
 		// Aggregate the tokens staked by the same address across multiple validators
 		amount := airdropMap[bech32Address]
 		airdropMap[bech32Address] = amount + tokenAirdrop.TruncateInt().Int64()
 	}
+
 	for address, amount := range airdropMap {
 		// Skip addresses that receive less than 1 token
 		if amount == 0 {
@@ -126,6 +130,7 @@ func Airdrop(stakingClient stakingtypes.QueryClient, configPath, blockHeight str
 			Coins:   sdktypes.NewCoins(sdktypes.NewCoin(tokenDenom, sdkmath.NewInt(amount))),
 		})
 	}
-	logger.Info("", zap.Int64("Total airdropped tokens", checkAmount))
+
+	logger.Info("Airdrop calculation complete", zap.Int64("totalAirdroppedTokens", checkAmount))
 	return balanceInfo, nil
 }