Added labels and updated log level

mirzakaracic · mirzakaracic · commit e5aab9667f35 · 2025-08-07T12:25:19.000-07:00
diff --git a/batch_delete_policy.go b/batch_delete_policy.go
@@ -133,15 +133,15 @@ func (bdp *BatchDeletePolicy) mapDynamic(dynConfig *DynConfig) *BatchDeletePolic
 		if dynConfig.config.Dynamic.BatchDelete.DurableDelete != nil {
 			configValue := *dynConfig.config.Dynamic.BatchDelete.DurableDelete
 			bdp.DurableDelete = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("DurableDelete set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("DurableDelete set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchDelete.SendKey != nil {
 			configValue := *dynConfig.config.Dynamic.BatchDelete.SendKey
 			bdp.SendKey = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("SendKey set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("SendKey set to %t", configValue)
 			}
 		}
 	}
diff --git a/batch_policy.go b/batch_policy.go
@@ -170,64 +170,64 @@ func (p *BatchPolicy) mapDynamic(dynConfig *DynConfig) *BatchPolicy {
 		if dynConfig.config.Dynamic.BatchRead.ReadModeAp != nil {
 			configValue := mapReadModeAPToReadModeAP(*dynConfig.config.Dynamic.BatchRead.ReadModeAp)
 			p.ReadModeAP = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("ReadModeAP set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("ReadModeAP set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.ReadModeSc != nil {
 			configValue := mapReadModeSCToReadModeSC(*dynConfig.config.Dynamic.BatchRead.ReadModeSc)
 			p.ReadModeSC = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("ReadModeSC set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("ReadModeSC set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.TotalTimeout != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.BatchRead.TotalTimeout) * time.Millisecond
 			p.TotalTimeout = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("TotalTimeout set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("TotalTimeout set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.SocketTimeout != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.BatchRead.SocketTimeout) * time.Millisecond
 			p.SocketTimeout = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("SocketTimeout set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("SocketTimeout set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.MaxRetries != nil {
 			configValue := *dynConfig.config.Dynamic.BatchRead.MaxRetries
 			p.MaxRetries = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("MaxRetries set to %d", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("MaxRetries set to %d", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.SleepBetweenRetries != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.BatchRead.SleepBetweenRetries) * time.Millisecond
 			p.SleepBetweenRetries = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("SleepBetweenRetries set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("SleepBetweenRetries set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.AllowInline != nil {
 			configValue := *dynConfig.config.Dynamic.BatchRead.AllowInline
 			p.AllowInline = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("AllowInline set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("AllowInline set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.AllowInlineSSD != nil {
 			configValue := *dynConfig.config.Dynamic.BatchRead.AllowInlineSSD
 			p.AllowInlineSSD = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("AllowInlineSSD set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("AllowInlineSSD set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.RespondAllKeys != nil {
 			configValue := *dynConfig.config.Dynamic.BatchRead.RespondAllKeys
 			p.RespondAllKeys = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("RespondAllKeys set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("RespondAllKeys set to %t", configValue)
 			}
 		}
 	}
diff --git a/batch_read_policy.go b/batch_read_policy.go
@@ -116,15 +116,15 @@ func (brp *BatchReadPolicy) mapDynamic(dynConfig *DynConfig) *BatchReadPolicy {
 		if dynConfig.config.Dynamic.BatchRead.ReadModeAp != nil {
 			configValue := mapReadModeAPToReadModeAP(*dynConfig.config.Dynamic.BatchRead.ReadModeAp)
 			brp.ReadModeAP = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("ReadModeAP set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("ReadModeAP set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.BatchRead.ReadModeSc != nil {
 			configValue := mapReadModeSCToReadModeSC(*dynConfig.config.Dynamic.BatchRead.ReadModeSc)
 			brp.ReadModeSC = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("ReadModeSC set to %s", configValue.String())
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("ReadModeSC set to %s", configValue.String())
 			}
 		}
 	}
diff --git a/batch_udf_policy.go b/batch_udf_policy.go
@@ -140,15 +140,15 @@ func (bup *BatchUDFPolicy) mapDynamic(dynConfig *DynConfig) *BatchUDFPolicy {
 		if dynConfig.config.Dynamic.BatchUdf.DurableDelete != nil {
 			configValue := *dynConfig.config.Dynamic.BatchUdf.DurableDelete
 			bup.DurableDelete = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("DurableDelete set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("DurableDelete set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchUdf.SendKey != nil {
 			configValue := *dynConfig.config.Dynamic.BatchUdf.SendKey
 			bup.SendKey = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("SendKey set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("SendKey set to %t", configValue)
 			}
 		}
 	}
diff --git a/batch_write_policy.go b/batch_write_policy.go
@@ -158,15 +158,15 @@ func (bwp *BatchWritePolicy) mapDynamic(dynConfig *DynConfig) *BatchWritePolicy
 		if dynConfig.config.Dynamic.BatchWrite.DurableDelete != nil {
 			configValue := *dynConfig.config.Dynamic.BatchWrite.DurableDelete
 			bwp.DurableDelete = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("DurableDelete set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("DurableDelete set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.BatchWrite.SendKey != nil {
 			configValue := *dynConfig.config.Dynamic.BatchWrite.SendKey
 			bwp.SendKey = configValue
-			if dynConfig.configInitialized.Load() {
-				logger.Logger.Info("SendKey set to %t", configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Debug("SendKey set to %t", configValue)
 			}
 		}
 	}
diff --git a/client_policy.go b/client_policy.go
@@ -264,63 +264,63 @@ func (cp *ClientPolicy) mapDynamic(dynConfig *DynConfig) *ClientPolicy {
 		if dynConfig.config.Dynamic.Client.IdleTimeout != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.Client.IdleTimeout) * time.Second	
 			cp.IdleTimeout = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("IdleTimeout set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.Client.Timeout != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.Client.Timeout) * time.Millisecond 
 			cp.Timeout = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("Timeout set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.Client.ErrorRateWindow != nil {
 			configValue := *dynConfig.config.Dynamic.Client.ErrorRateWindow
 			cp.ErrorRateWindow = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("ErrorRateWindow set to %d", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.Client.MaxErrorRate != nil {
 			configValue := *dynConfig.config.Dynamic.Client.MaxErrorRate
 			cp.MaxErrorRate = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("MaxErrorRate set to %d", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.Client.LoginTimeout != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.Client.LoginTimeout) * time.Millisecond
 			cp.LoginTimeout = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("LoginTimeout set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.Client.RackAware != nil {
 			configValue := *dynConfig.config.Dynamic.Client.RackAware
 			cp.RackAware = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("RackAware set to %t", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.Client.RackIds != nil {
 			configValue := *dynConfig.config.Dynamic.Client.RackIds
 			cp.RackIds = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("RackIds set to %v", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.Client.TendInterval != nil {
 			configValue := time.Duration(*dynConfig.config.Dynamic.Client.TendInterval) * time.Millisecond
 			cp.TendInterval = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("TendInterval set to %s", configValue.String())
 			}
 		}
 		if dynConfig.config.Dynamic.Client.UseServiceAlternate != nil {
 			configValue := *dynConfig.config.Dynamic.Client.UseServiceAlternate
 			cp.UseServicesAlternate = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("UseServicesAlternate set to %t", configValue)
 			}
 		}
diff --git a/cluster.go b/cluster.go
@@ -15,6 +15,7 @@
 package aerospike
 
 import (
+	"maps"
 	"fmt"
 	"net"
 	"runtime/debug"
@@ -1036,13 +1037,7 @@ func (clstr *Cluster) getNodeLabels(metricPolicy *MetricsPolicy) *Labels {
 		}
 
 		// Merging user labels with node labels
-		if userLabels != nil && userLabels.Labels != nil {
-			for _, userLabel := range *userLabels.Labels {
-				for k, v := range userLabel {
-					entries[k] = v
-				}
-			}
-		}
+		maps.Copy(entries, userLabels.Labels)
 
 		// Reserved label names for the client
 		entries["node"] = nodes[node].GetName()
diff --git a/config.go b/config.go
@@ -45,8 +45,9 @@ type DynConfig struct {
 
 	metricsCallback func(config *dynconfig.Config, client *Client)
 
-	scheme string
-	dsn    string
+	scheme    string
+	dsn       string
+	logUpdate *atomic.Bool
 }
 
 func parseDsn(inputDsn string) map[string]string {
@@ -105,7 +106,9 @@ func newDynConfigWithCallBack(policy *ClientPolicy, fn func(config *dynconfig.Co
 		scheme:             schema,
 		dsn:                urlPath,
 		configProvider:     provider,
+		logUpdate:          &atomic.Bool{},
 	}
+	dynConfig.logUpdate.Store(false)
 	dynConfig.initConfig()
 
 	dynConfig.wgConfig.Add(1)
@@ -144,13 +147,17 @@ func (dc *DynConfig) runCallBack() {
 func (dc *DynConfig) providerLoadConfig() {
 	loadedConfig := dc.configProvider.LoadConfig(dc.dsn)
 	if loadedConfig != nil {
+		// If the config is updated we need to log changes
+		dc.logUpdate.Store(true)
 		if dc.config.Dynamic == nil {
 			logger.Logger.Warn("Dynamic configuration is enabled and configuration is empty. Configuration will load default policy values.")
 		}
 
 		dc.config.Dynamic = loadedConfig.Dynamic // This is updating the entire dynamic config object
 
 		dc.hydrateDynamicPolicyFromConfig()
+		// Once policies are hydrated we can turn logging off
+		dc.logUpdate.Store(false)
 		logger.Logger.Info("Dynamic configuration updated internal state from provider.")
 	}
 }
@@ -168,6 +175,7 @@ func (dc *DynConfig) initConfig() {
 		}
 
 		dc.configInitialized.Store(true)
+		dc.logUpdate.Store(false)
 		logger.Logger.Info("Dynamic configuration initialized...")
 	}
 }
diff --git a/config/dynconfig.go b/config/dynconfig.go
@@ -183,9 +183,10 @@ type TxnVerify struct {
 }
 
 type Metrics struct {
-	Enable         *bool `yaml:"enable"`
-	LatencyColumns *int  `yaml:"latency_columns"`
-	LatencyBase    *int  `yaml:"latency_base"`
+	Enable         *bool              `yaml:"enable"`
+	LatencyColumns *int               `yaml:"latency_columns"`
+	LatencyBase    *int               `yaml:"latency_base"`
+	Labels         *map[string]string `yaml:"labels"`
 }
 
 // ----------------------------------------------------------------
diff --git a/metadata_policy.go b/metadata_policy.go
@@ -1,19 +1,21 @@
 package aerospike
 
+import "maps"
+
 type Labels struct {
-	Labels *[]map[string]string
+	Labels map[string]string // Labels is a slice of maps, where each map represents a set of labels.
 }
 
 func NewLabels(pairs ...map[string]string) *Labels {
-	labels := make([]map[string]string, 0)
+	labels := make(map[string]string, 0)
 	for _, pairMap := range pairs {
 		if pairMap != nil || len(pairMap) > 0 {
-			labels = append(labels, pairMap)
+			maps.Copy(labels, pairMap)
 		}
 	}
 
 	mp := Labels{
-		Labels: &labels,
+		Labels: labels,
 	}
 	return &mp
 }
diff --git a/metrics_policy.go b/metrics_policy.go
@@ -132,17 +132,24 @@ func (mp *MetricsPolicy) mapDynamic(dynConfig *DynConfig) *MetricsPolicy {
 		if dynConfig.config.Dynamic.Metrics.LatencyColumns != nil {
 			configValue := *dynConfig.config.Dynamic.Metrics.LatencyColumns
 			mp.LatencyColumns = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("LatencyColumns set to %d", configValue)
 			}
 		}
 		if dynConfig.config.Dynamic.Metrics.LatencyBase != nil {
 			configValue := *dynConfig.config.Dynamic.Metrics.LatencyBase
 			mp.LatencyBase = configValue
-			if dynConfig.configInitialized.Load() {
+			if dynConfig.logUpdate.Load() {
 				logger.Logger.Info("LatencyBase set to %d", configValue)
 			}
 		}
+		if dynConfig.config.Dynamic.Metrics.Labels != nil {
+			configValue := *dynConfig.config.Dynamic.Metrics.Labels
+			mp.Labels = NewLabels(configValue)
+			if dynConfig.logUpdate.Load() {
+				logger.Logger.Info("Labels set to %+v", configValue)
+			}
+		}
 	}
 
 	return mp
diff --git a/node_stats.go b/node_stats.go
@@ -327,7 +327,7 @@ func (ns *nodeStats) aggregate(newStats *nodeStats) {
 
 func (ns nodeStats) MarshalJSON() ([]byte, error) {
 	return json.Marshal(&struct {
-		StatsLabels              []map[string]string                  `json:"labels,omitempty"`
+		StatsLabels              map[string]string                    `json:"labels,omitempty"`
 		ConnectionsAttempts      int                                  `json:"connections-attempts"`
 		ConnectionsSuccessful    int                                  `json:"connections-successful"`
 		ConnectionsFailed        int                                  `json:"connections-failed"`
@@ -361,7 +361,7 @@ func (ns nodeStats) MarshalJSON() ([]byte, error) {
 		ErrorCounts              map[string]map[string]map[string]int `json:"detailed-resultcode-counts"`
 		DetailedMetrics          map[string]map[string]*commandMetric `json:"detailed-metrics"`
 	}{
-		*ns.StatLabels.Labels,
+		ns.StatLabels.Labels,
 		ns.ConnectionsAttempts.Get(),
 		ns.ConnectionsSuccessful.Get(),
 		ns.ConnectionsFailed.Get(),
diff --git a/policy.go b/policy.go
diff --git a/query_policy.go b/query_policy.go
diff --git a/scan_policy.go b/scan_policy.go
diff --git a/txn_roll_policy.go b/txn_roll_policy.go
diff --git a/txn_verify_policy.go b/txn_verify_policy.go
diff --git a/write_policy.go b/write_policy.go

Original file line number	Diff line number	Diff line change
`@@ -133,15 +133,15 @@ func (bdp BatchDeletePolicy) mapDynamic(dynConfig DynConfig) *BatchDeletePolic`
`133`	`133`	`if dynConfig.config.Dynamic.BatchDelete.DurableDelete != nil {`
`134`	`134`	`configValue := *dynConfig.config.Dynamic.BatchDelete.DurableDelete`
`135`	`135`	`bdp.DurableDelete = configValue`
`136`		`- if dynConfig.configInitialized.Load() {`
`137`		`- logger.Logger.Info("DurableDelete set to %t", configValue)`
	`136`	`+ if dynConfig.logUpdate.Load() {`
	`137`	`+ logger.Logger.Debug("DurableDelete set to %t", configValue)`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`	`if dynConfig.config.Dynamic.BatchDelete.SendKey != nil {`
`141`	`141`	`configValue := *dynConfig.config.Dynamic.BatchDelete.SendKey`
`142`	`142`	`bdp.SendKey = configValue`
`143`		`- if dynConfig.configInitialized.Load() {`
`144`		`- logger.Logger.Info("SendKey set to %t", configValue)`
	`143`	`+ if dynConfig.logUpdate.Load() {`
	`144`	`+ logger.Logger.Debug("SendKey set to %t", configValue)`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,64 +170,64 @@ func (p BatchPolicy) mapDynamic(dynConfig DynConfig) *BatchPolicy {`
`170`	`170`	`if dynConfig.config.Dynamic.BatchRead.ReadModeAp != nil {`
`171`	`171`	`configValue := mapReadModeAPToReadModeAP(*dynConfig.config.Dynamic.BatchRead.ReadModeAp)`
`172`	`172`	`p.ReadModeAP = configValue`
`173`		`- if dynConfig.configInitialized.Load() {`
`174`		`- logger.Logger.Info("ReadModeAP set to %s", configValue.String())`
	`173`	`+ if dynConfig.logUpdate.Load() {`
	`174`	`+ logger.Logger.Debug("ReadModeAP set to %s", configValue.String())`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`if dynConfig.config.Dynamic.BatchRead.ReadModeSc != nil {`
`178`	`178`	`configValue := mapReadModeSCToReadModeSC(*dynConfig.config.Dynamic.BatchRead.ReadModeSc)`
`179`	`179`	`p.ReadModeSC = configValue`
`180`		`- if dynConfig.configInitialized.Load() {`
`181`		`- logger.Logger.Info("ReadModeSC set to %s", configValue.String())`
	`180`	`+ if dynConfig.logUpdate.Load() {`
	`181`	`+ logger.Logger.Debug("ReadModeSC set to %s", configValue.String())`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`	`if dynConfig.config.Dynamic.BatchRead.TotalTimeout != nil {`
`185`	`185`	`configValue := time.Duration(dynConfig.config.Dynamic.BatchRead.TotalTimeout) time.Millisecond`
`186`	`186`	`p.TotalTimeout = configValue`
`187`		`- if dynConfig.configInitialized.Load() {`
`188`		`- logger.Logger.Info("TotalTimeout set to %s", configValue.String())`
	`187`	`+ if dynConfig.logUpdate.Load() {`
	`188`	`+ logger.Logger.Debug("TotalTimeout set to %s", configValue.String())`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`	`if dynConfig.config.Dynamic.BatchRead.SocketTimeout != nil {`
`192`	`192`	`configValue := time.Duration(dynConfig.config.Dynamic.BatchRead.SocketTimeout) time.Millisecond`
`193`	`193`	`p.SocketTimeout = configValue`
`194`		`- if dynConfig.configInitialized.Load() {`
`195`		`- logger.Logger.Info("SocketTimeout set to %s", configValue.String())`
	`194`	`+ if dynConfig.logUpdate.Load() {`
	`195`	`+ logger.Logger.Debug("SocketTimeout set to %s", configValue.String())`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`	`if dynConfig.config.Dynamic.BatchRead.MaxRetries != nil {`
`199`	`199`	`configValue := *dynConfig.config.Dynamic.BatchRead.MaxRetries`
`200`	`200`	`p.MaxRetries = configValue`
`201`		`- if dynConfig.configInitialized.Load() {`
`202`		`- logger.Logger.Info("MaxRetries set to %d", configValue)`
	`201`	`+ if dynConfig.logUpdate.Load() {`
	`202`	`+ logger.Logger.Debug("MaxRetries set to %d", configValue)`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`	`if dynConfig.config.Dynamic.BatchRead.SleepBetweenRetries != nil {`
`206`	`206`	`configValue := time.Duration(dynConfig.config.Dynamic.BatchRead.SleepBetweenRetries) time.Millisecond`
`207`	`207`	`p.SleepBetweenRetries = configValue`
`208`		`- if dynConfig.configInitialized.Load() {`
`209`		`- logger.Logger.Info("SleepBetweenRetries set to %s", configValue.String())`
	`208`	`+ if dynConfig.logUpdate.Load() {`
	`209`	`+ logger.Logger.Debug("SleepBetweenRetries set to %s", configValue.String())`
`210`	`210`	`}`
`211`	`211`	`}`
`212`	`212`	`if dynConfig.config.Dynamic.BatchRead.AllowInline != nil {`
`213`	`213`	`configValue := *dynConfig.config.Dynamic.BatchRead.AllowInline`
`214`	`214`	`p.AllowInline = configValue`
`215`		`- if dynConfig.configInitialized.Load() {`
`216`		`- logger.Logger.Info("AllowInline set to %t", configValue)`
	`215`	`+ if dynConfig.logUpdate.Load() {`
	`216`	`+ logger.Logger.Debug("AllowInline set to %t", configValue)`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`if dynConfig.config.Dynamic.BatchRead.AllowInlineSSD != nil {`
`220`	`220`	`configValue := *dynConfig.config.Dynamic.BatchRead.AllowInlineSSD`
`221`	`221`	`p.AllowInlineSSD = configValue`
`222`		`- if dynConfig.configInitialized.Load() {`
`223`		`- logger.Logger.Info("AllowInlineSSD set to %t", configValue)`
	`222`	`+ if dynConfig.logUpdate.Load() {`
	`223`	`+ logger.Logger.Debug("AllowInlineSSD set to %t", configValue)`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`	`if dynConfig.config.Dynamic.BatchRead.RespondAllKeys != nil {`
`227`	`227`	`configValue := *dynConfig.config.Dynamic.BatchRead.RespondAllKeys`
`228`	`228`	`p.RespondAllKeys = configValue`
`229`		`- if dynConfig.configInitialized.Load() {`
`230`		`- logger.Logger.Info("RespondAllKeys set to %t", configValue)`
	`229`	`+ if dynConfig.logUpdate.Load() {`
	`230`	`+ logger.Logger.Debug("RespondAllKeys set to %t", configValue)`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,15 +116,15 @@ func (brp BatchReadPolicy) mapDynamic(dynConfig DynConfig) *BatchReadPolicy {`
`116`	`116`	`if dynConfig.config.Dynamic.BatchRead.ReadModeAp != nil {`
`117`	`117`	`configValue := mapReadModeAPToReadModeAP(*dynConfig.config.Dynamic.BatchRead.ReadModeAp)`
`118`	`118`	`brp.ReadModeAP = configValue`
`119`		`- if dynConfig.configInitialized.Load() {`
`120`		`- logger.Logger.Info("ReadModeAP set to %s", configValue.String())`
	`119`	`+ if dynConfig.logUpdate.Load() {`
	`120`	`+ logger.Logger.Debug("ReadModeAP set to %s", configValue.String())`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`if dynConfig.config.Dynamic.BatchRead.ReadModeSc != nil {`
`124`	`124`	`configValue := mapReadModeSCToReadModeSC(*dynConfig.config.Dynamic.BatchRead.ReadModeSc)`
`125`	`125`	`brp.ReadModeSC = configValue`
`126`		`- if dynConfig.configInitialized.Load() {`
`127`		`- logger.Logger.Info("ReadModeSC set to %s", configValue.String())`
	`126`	`+ if dynConfig.logUpdate.Load() {`
	`127`	`+ logger.Logger.Debug("ReadModeSC set to %s", configValue.String())`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -140,15 +140,15 @@ func (bup BatchUDFPolicy) mapDynamic(dynConfig DynConfig) *BatchUDFPolicy {`
`140`	`140`	`if dynConfig.config.Dynamic.BatchUdf.DurableDelete != nil {`
`141`	`141`	`configValue := *dynConfig.config.Dynamic.BatchUdf.DurableDelete`
`142`	`142`	`bup.DurableDelete = configValue`
`143`		`- if dynConfig.configInitialized.Load() {`
`144`		`- logger.Logger.Info("DurableDelete set to %t", configValue)`
	`143`	`+ if dynConfig.logUpdate.Load() {`
	`144`	`+ logger.Logger.Debug("DurableDelete set to %t", configValue)`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`if dynConfig.config.Dynamic.BatchUdf.SendKey != nil {`
`148`	`148`	`configValue := *dynConfig.config.Dynamic.BatchUdf.SendKey`
`149`	`149`	`bup.SendKey = configValue`
`150`		`- if dynConfig.configInitialized.Load() {`
`151`		`- logger.Logger.Info("SendKey set to %t", configValue)`
	`150`	`+ if dynConfig.logUpdate.Load() {`
	`151`	`+ logger.Logger.Debug("SendKey set to %t", configValue)`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,15 +158,15 @@ func (bwp BatchWritePolicy) mapDynamic(dynConfig DynConfig) *BatchWritePolicy`
`158`	`158`	`if dynConfig.config.Dynamic.BatchWrite.DurableDelete != nil {`
`159`	`159`	`configValue := *dynConfig.config.Dynamic.BatchWrite.DurableDelete`
`160`	`160`	`bwp.DurableDelete = configValue`
`161`		`- if dynConfig.configInitialized.Load() {`
`162`		`- logger.Logger.Info("DurableDelete set to %t", configValue)`
	`161`	`+ if dynConfig.logUpdate.Load() {`
	`162`	`+ logger.Logger.Debug("DurableDelete set to %t", configValue)`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`	`if dynConfig.config.Dynamic.BatchWrite.SendKey != nil {`
`166`	`166`	`configValue := *dynConfig.config.Dynamic.BatchWrite.SendKey`
`167`	`167`	`bwp.SendKey = configValue`
`168`		`- if dynConfig.configInitialized.Load() {`
`169`		`- logger.Logger.Info("SendKey set to %t", configValue)`
	`168`	`+ if dynConfig.logUpdate.Load() {`
	`169`	`+ logger.Logger.Debug("SendKey set to %t", configValue)`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -264,63 +264,63 @@ func (cp ClientPolicy) mapDynamic(dynConfig DynConfig) *ClientPolicy {`
`264`	`264`	`if dynConfig.config.Dynamic.Client.IdleTimeout != nil {`
`265`	`265`	`configValue := time.Duration(dynConfig.config.Dynamic.Client.IdleTimeout) time.Second`
`266`	`266`	`cp.IdleTimeout = configValue`
`267`		`- if dynConfig.configInitialized.Load() {`
	`267`	`+ if dynConfig.logUpdate.Load() {`
`268`	`268`	`logger.Logger.Info("IdleTimeout set to %s", configValue.String())`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`	`if dynConfig.config.Dynamic.Client.Timeout != nil {`
`272`	`272`	`configValue := time.Duration(dynConfig.config.Dynamic.Client.Timeout) time.Millisecond`
`273`	`273`	`cp.Timeout = configValue`
`274`		`- if dynConfig.configInitialized.Load() {`
	`274`	`+ if dynConfig.logUpdate.Load() {`
`275`	`275`	`logger.Logger.Info("Timeout set to %s", configValue.String())`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`	`if dynConfig.config.Dynamic.Client.ErrorRateWindow != nil {`
`279`	`279`	`configValue := *dynConfig.config.Dynamic.Client.ErrorRateWindow`
`280`	`280`	`cp.ErrorRateWindow = configValue`
`281`		`- if dynConfig.configInitialized.Load() {`
	`281`	`+ if dynConfig.logUpdate.Load() {`
`282`	`282`	`logger.Logger.Info("ErrorRateWindow set to %d", configValue)`
`283`	`283`	`}`
`284`	`284`	`}`
`285`	`285`	`if dynConfig.config.Dynamic.Client.MaxErrorRate != nil {`
`286`	`286`	`configValue := *dynConfig.config.Dynamic.Client.MaxErrorRate`
`287`	`287`	`cp.MaxErrorRate = configValue`
`288`		`- if dynConfig.configInitialized.Load() {`
	`288`	`+ if dynConfig.logUpdate.Load() {`
`289`	`289`	`logger.Logger.Info("MaxErrorRate set to %d", configValue)`
`290`	`290`	`}`
`291`	`291`	`}`
`292`	`292`	`if dynConfig.config.Dynamic.Client.LoginTimeout != nil {`
`293`	`293`	`configValue := time.Duration(dynConfig.config.Dynamic.Client.LoginTimeout) time.Millisecond`
`294`	`294`	`cp.LoginTimeout = configValue`
`295`		`- if dynConfig.configInitialized.Load() {`
	`295`	`+ if dynConfig.logUpdate.Load() {`
`296`	`296`	`logger.Logger.Info("LoginTimeout set to %s", configValue.String())`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`	`if dynConfig.config.Dynamic.Client.RackAware != nil {`
`300`	`300`	`configValue := *dynConfig.config.Dynamic.Client.RackAware`
`301`	`301`	`cp.RackAware = configValue`
`302`		`- if dynConfig.configInitialized.Load() {`
	`302`	`+ if dynConfig.logUpdate.Load() {`
`303`	`303`	`logger.Logger.Info("RackAware set to %t", configValue)`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`	`if dynConfig.config.Dynamic.Client.RackIds != nil {`
`307`	`307`	`configValue := *dynConfig.config.Dynamic.Client.RackIds`
`308`	`308`	`cp.RackIds = configValue`
`309`		`- if dynConfig.configInitialized.Load() {`
	`309`	`+ if dynConfig.logUpdate.Load() {`
`310`	`310`	`logger.Logger.Info("RackIds set to %v", configValue)`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`	`if dynConfig.config.Dynamic.Client.TendInterval != nil {`
`314`	`314`	`configValue := time.Duration(dynConfig.config.Dynamic.Client.TendInterval) time.Millisecond`
`315`	`315`	`cp.TendInterval = configValue`
`316`		`- if dynConfig.configInitialized.Load() {`
	`316`	`+ if dynConfig.logUpdate.Load() {`
`317`	`317`	`logger.Logger.Info("TendInterval set to %s", configValue.String())`
`318`	`318`	`}`
`319`	`319`	`}`
`320`	`320`	`if dynConfig.config.Dynamic.Client.UseServiceAlternate != nil {`
`321`	`321`	`configValue := *dynConfig.config.Dynamic.Client.UseServiceAlternate`
`322`	`322`	`cp.UseServicesAlternate = configValue`
`323`		`- if dynConfig.configInitialized.Load() {`
	`323`	`+ if dynConfig.logUpdate.Load() {`
`324`	`324`	`logger.Logger.Info("UseServicesAlternate set to %t", configValue)`
`325`	`325`	`}`
`326`	`326`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,9 @@ type DynConfig struct {`
`45`	`45`
`46`	`46`	`metricsCallback func(config dynconfig.Config, client Client)`
`47`	`47`
`48`		`- scheme string`
`49`		`- dsn string`
	`48`	`+ scheme string`
	`49`	`+ dsn string`
	`50`	`+ logUpdate *atomic.Bool`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`func parseDsn(inputDsn string) map[string]string {`
`@@ -105,7 +106,9 @@ func newDynConfigWithCallBack(policy ClientPolicy, fn func(config dynconfig.Co`
`105`	`106`	`scheme: schema,`
`106`	`107`	`dsn: urlPath,`
`107`	`108`	`configProvider: provider,`
	`109`	`+ logUpdate: &atomic.Bool{},`
`108`	`110`	`}`
	`111`	`+ dynConfig.logUpdate.Store(false)`
`109`	`112`	`dynConfig.initConfig()`
`110`	`113`
`111`	`114`	`dynConfig.wgConfig.Add(1)`
`@@ -144,13 +147,17 @@ func (dc *DynConfig) runCallBack() {`
`144`	`147`	`func (dc *DynConfig) providerLoadConfig() {`
`145`	`148`	`loadedConfig := dc.configProvider.LoadConfig(dc.dsn)`
`146`	`149`	`if loadedConfig != nil {`
	`150`	`+ // If the config is updated we need to log changes`
	`151`	`+ dc.logUpdate.Store(true)`
`147`	`152`	`if dc.config.Dynamic == nil {`
`148`	`153`	`logger.Logger.Warn("Dynamic configuration is enabled and configuration is empty. Configuration will load default policy values.")`
`149`	`154`	`}`
`150`	`155`
`151`	`156`	`dc.config.Dynamic = loadedConfig.Dynamic // This is updating the entire dynamic config object`
`152`	`157`
`153`	`158`	`dc.hydrateDynamicPolicyFromConfig()`
	`159`	`+ // Once policies are hydrated we can turn logging off`
	`160`	`+ dc.logUpdate.Store(false)`
`154`	`161`	`logger.Logger.Info("Dynamic configuration updated internal state from provider.")`
`155`	`162`	`}`
`156`	`163`	`}`
`@@ -168,6 +175,7 @@ func (dc *DynConfig) initConfig() {`
`168`	`175`	`}`
`169`	`176`
`170`	`177`	`dc.configInitialized.Store(true)`
	`178`	`+ dc.logUpdate.Store(false)`
`171`	`179`	`logger.Logger.Info("Dynamic configuration initialized...")`
`172`	`180`	`}`
`173`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -183,9 +183,10 @@ type TxnVerify struct {`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`type Metrics struct {`
`186`		- Enable *bool `yaml:"enable"`
`187`		- LatencyColumns *int `yaml:"latency_columns"`
`188`		- LatencyBase *int `yaml:"latency_base"`
	`186`	+ Enable *bool `yaml:"enable"`
	`187`	+ LatencyColumns *int `yaml:"latency_columns"`
	`188`	+ LatencyBase *int `yaml:"latency_base"`
	`189`	+ Labels *map[string]string `yaml:"labels"`
`189`	`190`	`}`
`190`	`191`
`191`	`192`	`// ----------------------------------------------------------------`
Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,21 @@`
`1`	`1`	`package aerospike`
`2`	`2`
	`3`	`+import "maps"`
	`4`	`+`
`3`	`5`	`type Labels struct {`
`4`		`- Labels *[]map[string]string`
	`6`	`+ Labels map[string]string // Labels is a slice of maps, where each map represents a set of labels.`
`5`	`7`	`}`
`6`	`8`
`7`	`9`	`func NewLabels(pairs ...map[string]string) *Labels {`
`8`		`- labels := make([]map[string]string, 0)`
	`10`	`+ labels := make(map[string]string, 0)`
`9`	`11`	`for _, pairMap := range pairs {`
`10`	`12`	`if pairMap != nil \|\| len(pairMap) > 0 {`
`11`		`- labels = append(labels, pairMap)`
	`13`	`+ maps.Copy(labels, pairMap)`
`12`	`14`	`}`
`13`	`15`	`}`
`14`	`16`
`15`	`17`	`mp := Labels{`
`16`		`- Labels: &labels,`
	`18`	`+ Labels: labels,`
`17`	`19`	`}`
`18`	`20`	`return &mp`
`19`	`21`	`}`