feat: add reporting config with reload (#16970)

Co-authored-by: Poonam Jadhav <[email protected]>

agent/agent.go

@@ -1360,7 +1360,10 @@ func newConsulConfig(runtimeCfg *config.RuntimeConfig, logger hclog.Logger) (*co
 	cfg.PeeringEnabled = runtimeCfg.PeeringEnabled
 	cfg.PeeringTestAllowPeerRegistrations = runtimeCfg.PeeringTestAllowPeerRegistrations
 
+	cfg.Reporting.License.Enabled = runtimeCfg.Reporting.License.Enabled
+
 	enterpriseConsulConfig(cfg, runtimeCfg)
+
 	return cfg, nil
 }
 
@@ -4007,6 +4010,11 @@ func (a *Agent) reloadConfigInternal(newCfg *config.RuntimeConfig) error {
 		HeartbeatTimeout:      newCfg.ConsulRaftHeartbeatTimeout,
 		ElectionTimeout:       newCfg.ConsulRaftElectionTimeout,
 		RaftTrailingLogs:      newCfg.RaftTrailingLogs,
+		Reporting: consul.Reporting{
+			License: consul.License{
+				Enabled: newCfg.Reporting.License.Enabled,
+			},
+		},
 	}
 	if err := a.delegate.ReloadConfig(cc); err != nil {
 		return err

agent/agent_oss_test.go

@@ -0,0 +1,46 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+//go:build !consulent
+// +build !consulent
+
+package agent
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAgent_consulConfig_Reporting(t *testing.T) {
+	if testing.Short() {
+		t.Skip("too slow for testing.Short")
+	}
+
+	t.Parallel()
+	hcl := `
+		reporting {
+			license {
+				enabled = true
+			}
+		}
+	`
+	a := NewTestAgent(t, hcl)
+	defer a.Shutdown()
+	require.Equal(t, false, a.consulConfig().Reporting.License.Enabled)
+}
+
+func TestAgent_consulConfig_Reporting_Default(t *testing.T) {
+	if testing.Short() {
+		t.Skip("too slow for testing.Short")
+	}
+
+	t.Parallel()
+	hcl := `
+		reporting {
+		}
+	`
+	a := NewTestAgent(t, hcl)
+	defer a.Shutdown()
+	require.Equal(t, false, a.consulConfig().Reporting.License.Enabled)
+}

agent/config/builder_oss.go

@@ -57,6 +57,10 @@ func validateEnterpriseConfigKeys(config *Config) []error {
 		add("license_path")
 		config.LicensePath = nil
 	}
+	if config.Reporting.License.Enabled != nil {
+		add("reporting.license.enabled")
+		config.Reporting.License.Enabled = nil
+	}
 
 	return result
 }

agent/config/builder_oss_test.go

@@ -107,6 +107,19 @@ func TestValidateEnterpriseConfigKeys(t *testing.T) {
 				require.Empty(t, c.LicensePath)
 			},
 		},
+		"reporting.license.enabled": {
+			config: Config{
+				Reporting: Reporting{
+					License: License{
+						Enabled: &boolVal,
+					},
+				},
+			},
+			badKeys: []string{"reporting.license.enabled"},
+			check: func(t *testing.T, c *Config) {
+				require.Nil(t, c.Reporting.License.Enabled)
+			},
+		},
 		"multi": {
 			config: Config{
 				ReadReplica: &boolVal,

agent/config/config.go

@@ -298,6 +298,9 @@ type Config struct {
 	LicensePollMaxTime    *string `mapstructure:"license_poll_max_time"`
 	LicenseUpdateBaseTime *string `mapstructure:"license_update_base_time"`
 	LicenseUpdateMaxTime  *string `mapstructure:"license_update_max_time"`
+
+	// license reporting
+	Reporting Reporting `mapstructure:"reporting"`
 }
 
 type GossipLANConfig struct {
@@ -924,3 +927,11 @@ type Peering struct {
 	// This always gets overridden in NonUserSource()
 	TestAllowPeerRegistrations *bool `mapstructure:"test_allow_peer_registrations"`
 }
+
+type License struct {
+	Enabled *bool `mapstructure:"enabled"`
+}
+
+type Reporting struct {
+	License License `mapstructure:"license"`
+}

agent/config/runtime.go

@@ -1429,9 +1429,19 @@ type RuntimeConfig struct {
 	// AutoReloadConfigCoalesceInterval Coalesce Interval for auto reload config
 	AutoReloadConfigCoalesceInterval time.Duration
 
+	Reporting ReportingConfig
+
 	EnterpriseRuntimeConfig
 }
 
+type LicenseConfig struct {
+	Enabled bool
+}
+
+type ReportingConfig struct {
+	License LicenseConfig
+}
+
 type AutoConfig struct {
 	Enabled         bool
 	IntroToken      string

agent/config/runtime_oss_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/hashicorp/consul/sdk/testutil"
+	"github.com/stretchr/testify/require"
 )
 
 var testRuntimeConfigSanitizeExpectedFilename = "TestRuntimeConfig_Sanitize.golden"
@@ -27,6 +28,7 @@ var enterpriseConfigKeyWarnings = []string{
 	enterpriseConfigKeyError{key: "acl.msp_disable_bootstrap"}.Error(),
 	enterpriseConfigKeyError{key: "acl.tokens.managed_service_provider"}.Error(),
 	enterpriseConfigKeyError{key: "audit"}.Error(),
+	enterpriseConfigKeyError{key: "reporting.license.enabled"}.Error(),
 }
 
 // OSS-only equivalent of TestConfigFlagsAndEdgecases
@@ -80,3 +82,82 @@ func TestLoad_IntegrationWithFlags_OSS(t *testing.T) {
 		}
 	}
 }
+
+func TestLoad_ReportingConfig(t *testing.T) {
+	dir := testutil.TempDir(t, t.Name())
+
+	t.Run("load from JSON defaults to false", func(t *testing.T) {
+		content := `{
+			"reporting": {}
+		}`
+
+		opts := LoadOpts{
+			FlagValues: Config{
+				DataDir: &dir,
+			},
+			Overrides: []Source{
+				FileSource{
+					Name:   "reporting.json",
+					Format: "json",
+					Data:   content,
+				},
+			},
+		}
+		patchLoadOptsShims(&opts)
+		result, err := Load(opts)
+		require.NoError(t, err)
+		require.Len(t, result.Warnings, 0)
+		require.Equal(t, false, result.RuntimeConfig.Reporting.License.Enabled)
+	})
+
+	t.Run("load from HCL defaults to false", func(t *testing.T) {
+		content := `
+		  reporting {}
+		`
+
+		opts := LoadOpts{
+			FlagValues: Config{
+				DataDir: &dir,
+			},
+			Overrides: []Source{
+				FileSource{
+					Name:   "reporting.hcl",
+					Format: "hcl",
+					Data:   content,
+				},
+			},
+		}
+		patchLoadOptsShims(&opts)
+		result, err := Load(opts)
+		require.NoError(t, err)
+		require.Len(t, result.Warnings, 0)
+		require.Equal(t, false, result.RuntimeConfig.Reporting.License.Enabled)
+	})
+
+	t.Run("with value set returns warning and defaults to false", func(t *testing.T) {
+		content := `reporting {
+			license {
+			  enabled = true
+			}
+		}`
+
+		opts := LoadOpts{
+			FlagValues: Config{
+				DataDir: &dir,
+			},
+			Overrides: []Source{
+				FileSource{
+					Name:   "reporting.hcl",
+					Format: "hcl",
+					Data:   content,
+				},
+			},
+		}
+		patchLoadOptsShims(&opts)
+		result, err := Load(opts)
+		require.NoError(t, err)
+		require.Len(t, result.Warnings, 1)
+		require.Contains(t, result.Warnings[0], "\"reporting.license.enabled\" is a Consul Enterprise configuration and will have no effect")
+		require.Equal(t, false, result.RuntimeConfig.Reporting.License.Enabled)
+	})
+}

agent/config/testdata/TestRuntimeConfig_Sanitize.golden

@@ -266,6 +266,11 @@
     "ReconnectTimeoutLAN": "0s",
     "ReconnectTimeoutWAN": "0s",
     "RejoinAfterLeave": false,
+    "Reporting": {
+        "License": {
+            "Enabled": false
+        }
+    },
     "RetryJoinIntervalLAN": "0s",
     "RetryJoinIntervalWAN": "0s",
     "RetryJoinLAN": [

agent/config/testdata/full-config.hcl

@@ -344,6 +344,11 @@ reconnect_timeout = "23739s"
 reconnect_timeout_wan = "26694s"
 recursors = [ "63.38.39.58", "92.49.18.18" ]
 rejoin_after_leave = true
+reporting = {
+    license = {
+        enabled = false
+    }
+}
 retry_interval = "8067s"
 retry_interval_wan = "28866s"
 retry_join = [ "pbsSFY7U", "l0qLtWij" ]

agent/config/testdata/full-config.json

@@ -342,6 +342,11 @@
   "reconnect_timeout_wan": "26694s",
   "recursors": [ "63.38.39.58", "92.49.18.18" ],
   "rejoin_after_leave": true,
+  "reporting": {
+    "license": {
+      "enabled": false
+    }
+  },
   "retry_interval": "8067s",
   "retry_interval_wan": "28866s",
   "retry_join": [ "pbsSFY7U", "l0qLtWij" ],

agent/consul/config.go

@@ -408,6 +408,8 @@ type Config struct {
 
 	PeeringTestAllowPeerRegistrations bool
 
+	Reporting Reporting
+
 	// Embedded Consul Enterprise specific configuration
 	*EnterpriseConfig
 }
@@ -630,8 +632,17 @@ type ReloadableConfig struct {
 	RaftTrailingLogs      int
 	HeartbeatTimeout      time.Duration
 	ElectionTimeout       time.Duration
+	Reporting             Reporting
 }
 
 type RaftBoltDBConfig struct {
 	NoFreelistSync bool
 }
+
+type License struct {
+	Enabled bool
+}
+
+type Reporting struct {
+	License License
+}

agent/consul/server.go

@@ -1618,6 +1618,8 @@ func (s *Server) ReloadConfig(config ReloadableConfig) error {
 		return err
 	}
 
+	s.updateReportingConfig(config)
+
 	s.rpcLimiter.Store(rate.NewLimiter(config.RPCRateLimit, config.RPCMaxBurst))
 	s.rpcConnLimiter.SetConfig(connlimit.Config{
 		MaxConnsPerClientIP: config.RPCMaxConnsPerClient,

agent/consul/server_oss.go

@@ -174,3 +174,7 @@ func addSerfMetricsLabels(conf *serf.Config, wan bool, segment string, partition
 
 	conf.MetricLabels = append(conf.MetricLabels, networkMetric)
 }
+
+func (s *Server) updateReportingConfig(config ReloadableConfig) {
+	// no-op
+}

agent/consul/server_oss_test.go

@@ -0,0 +1,43 @@
+//go:build !consulent
+// +build !consulent
+
+package consul
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/hashicorp/consul/testrpc"
+)
+
+func TestAgent_ReloadConfig_Reporting(t *testing.T) {
+	if testing.Short() {
+		t.Skip("too slow for testing.Short")
+	}
+	t.Parallel()
+
+	dir1, s := testServerWithConfig(t, func(c *Config) {
+		c.Reporting.License.Enabled = false
+	})
+	defer os.RemoveAll(dir1)
+	defer s.Shutdown()
+
+	testrpc.WaitForTestAgent(t, s.RPC, "dc1")
+
+	require.Equal(t, false, s.config.Reporting.License.Enabled)
+
+	rc := ReloadableConfig{
+		Reporting: Reporting{
+			License: License{
+				Enabled: true,
+			},
+		},
+	}
+
+	require.NoError(t, s.ReloadConfig(rc))
+
+	// Check config reload is no-op
+	require.Equal(t, false, s.config.Reporting.License.Enabled)
+}