[NDMII-3310] add support for HA integrations

comp/collector/collector/collectorimpl/internal/middleware/check_wrapper.go

@@ -147,3 +147,8 @@ func (c *CheckWrapper) GetDiagnoses() ([]diagnosis.Diagnosis, error) {
 func (c *CheckWrapper) IsHAEnabled() bool {
 	return c.inner.IsHAEnabled()
 }
+
+// IsHASupported implements Check#IsHASupported
+func (c *CheckWrapper) IsHASupported() bool {
+	return c.inner.IsHASupported()
+}

pkg/collector/check/check.go

@@ -56,6 +56,8 @@ type Check interface {
 	GetDiagnoses() ([]diagnosis.Diagnosis, error)
 	// IsHAEnabled returns if High Availability is enabled for this check
 	IsHAEnabled() bool
+	// IsHASupported returns if the check is compatible with High Availability
+	IsHASupported() bool
 }
 
 // Info is an interface to pull information from types capable to run checks. This is a subsection from the Check

pkg/collector/check/stub/stub.go

@@ -73,3 +73,6 @@ func (c *StubCheck) GetDiagnoses() ([]diagnosis.Diagnosis, error) { return nil,
 
 // IsHAEnabled returns false
 func (c *StubCheck) IsHAEnabled() bool { return false }
+
+// IsHASupported returns false
+func (c *StubCheck) IsHASupported() bool { return false }

pkg/collector/corechecks/checkbase.go

@@ -153,6 +153,9 @@ func (c *CheckBase) CommonConfigure(senderManager sender.SenderManager, initConf
 
 		if commonOptions.HAEnabled != nil {
 			c.haEnabled = *commonOptions.HAEnabled
+			if c.haEnabled && !c.IsHASupported() {
+				return fmt.Errorf("High Availability is enabled for check %s but this integration does not support it", string(c.ID()))
+			}
 		}
 
 		c.source = source
@@ -295,3 +298,8 @@ func (c *CheckBase) GetDiagnoses() ([]diagnosis.Diagnosis, error) {
 func (c *CheckBase) IsHAEnabled() bool {
 	return c.haEnabled
 }
+
+// IsHASupported returns if the check is compatible with High Availability
+func (c *CheckBase) IsHASupported() bool {
+	return false
+}

pkg/collector/corechecks/checkbase_test.go

@@ -23,6 +23,10 @@ foo_init: bar_init
 min_collection_interval: 60
 empty_default_hostname: true
 name: foobar
+`
+	haConfig = `
+foo_init: bar_init
+ha_enabled: true
 `
 )
 
@@ -68,3 +72,19 @@ func TestCommonConfigureCustomID(t *testing.T) {
 	assert.Equal(t, string(mycheck.ID()), "test:foobar:a934df33209f45f4")
 	mockSender.AssertExpectations(t)
 }
+
+func TestCommonConfigureNotHASupported(t *testing.T) {
+	checkName := "test"
+	mycheck := &dummyCheck{
+		CheckBase: NewCheckBase(checkName),
+	}
+	mockSender := mocksender.NewMockSender(mycheck.ID())
+
+	err := mycheck.CommonConfigure(mockSender.GetSenderManager(), nil, []byte(haConfig), "test")
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "High Availability is enabled for check test but this integration does not support it")
+
+	err = mycheck.CommonConfigure(mockSender.GetSenderManager(), []byte(haConfig), nil, "test")
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "High Availability is enabled for check test but this integration does not support it")
+}

pkg/collector/corechecks/embed/apm/apm.go

@@ -259,6 +259,11 @@ func (c *APMCheck) IsHAEnabled() bool {
 	return false
 }
 
+// IsHASupported returns if the check is compatible with High Availability
+func (c *APMCheck) IsHASupported() bool {
+	return false
+}
+
 // Factory creates a new check factory
 func Factory() option.Option[func() check.Check] {
 	return option.New(newCheck)

pkg/collector/corechecks/embed/process/process_agent.go

@@ -253,6 +253,11 @@ func (c *ProcessAgentCheck) IsHAEnabled() bool {
 	return false
 }
 
+// IsHASupported returns if the check is compatible with High Availability
+func (c *ProcessAgentCheck) IsHASupported() bool {
+	return false
+}
+
 // Factory creates a new check factory
 func Factory() option.Option[func() check.Check] {
 	return option.New(newCheck)

pkg/collector/corechecks/longrunning_test.go

@@ -95,6 +95,11 @@ func (m *mockLongRunningCheck) IsHAEnabled() bool {
 	return args.Bool(0)
 }
 
+func (m *mockLongRunningCheck) IsHASupported() bool {
+	args := m.Called()
+	return args.Bool(0)
+}
+
 func (m *mockLongRunningCheck) GetSender() (sender.Sender, error) {
 	args := m.Called()
 	s := args.Get(0)

pkg/collector/corechecks/network-devices/cisco-sdwan/sdwan.go

@@ -290,6 +290,11 @@ func (c *CiscoSdwanCheck) Interval() time.Duration {
 	return c.interval
 }
 
+// IsHASupported returns true if the check supports HA
+func (c *CiscoSdwanCheck) IsHASupported() bool {
+	return true
+}
+
 func boolPointer(b bool) *bool {
 	return &b
 }

pkg/collector/corechecks/networkpath/networkpath.go

@@ -138,6 +138,11 @@ func (c *Check) Configure(senderManager sender.SenderManager, integrationConfigD
 	return nil
 }
 
+// IsHASupported returns true if the check supports HA
+func (c *Check) IsHASupported() bool {
+	return true
+}
+
 // Factory creates a new check factory
 func Factory(telemetry telemetryComp.Component) option.Option[func() check.Check] {
 	return option.New(func() check.Check {

pkg/collector/corechecks/snmp/snmp.go

@@ -196,6 +196,11 @@ func (c *Check) GetDiagnoses() ([]diagnosis.Diagnosis, error) {
 	return c.singleDeviceCk.GetDiagnoses(), nil
 }
 
+// IsHASupported returns true if the check supports HA
+func (c *Check) IsHASupported() bool {
+	return true
+}
+
 // Factory creates a new check factory
 func Factory(agentConfig config.Component) option.Option[func() check.Check] {
 	return option.New(func() check.Check {

pkg/collector/python/check.go

@@ -419,6 +419,13 @@ func (c *PythonCheck) IsHAEnabled() bool {
 	return c.haEnabled
 }
 
+// IsHASupported is actually not used, the HA Supported is defined at Python Check level as a class attribute
+// An exception is raised if a non HA Supported check is configured with ha_enabled config in the __init__ method of the AgentCheck class
+// https://github.com/DataDog/integrations-core/blob/master/datadog_checks_base/datadog_checks/base/checks/base.py#L98
+func (c *PythonCheck) IsHASupported() bool {
+	return false
+}
+
 // pythonCheckFinalizer is a finalizer that decreases the reference count on the PyObject refs owned
 // by the PythonCheck.
 func pythonCheckFinalizer(c *PythonCheck) {

pkg/jmxfetch/jmxfetch.go

@@ -112,13 +112,15 @@ type checkInstanceCfg struct {
 	JavaOptions      string `yaml:"java_options,omitempty"`
 	ToolsJarPath     string `yaml:"tools_jar_path,omitempty"`
 	ProcessNameRegex string `yaml:"process_name_regex,omitempty"`
+	HAEnabled        bool   `yaml:"ha_enabled,omitempty"`
 }
 
 type checkInitCfg struct {
 	CustomJarPaths []string `yaml:"custom_jar_paths,omitempty"`
 	ToolsJarPath   string   `yaml:"tools_jar_path,omitempty"`
 	JavaBinPath    string   `yaml:"java_bin_path,omitempty"`
 	JavaOptions    string   `yaml:"java_options,omitempty"`
+	HAEnabled      bool     `yaml:"ha_enabled,omitempty"`
 }
 
 func NewJMXFetch(logger jmxlogger.Component) *JMXFetch {
@@ -478,6 +480,9 @@ func (j *JMXFetch) ConfigureFromInitConfig(initConfig integration.Data) error {
 			j.JavaCustomJarPaths = initConf.CustomJarPaths
 		}
 	}
+	if initConf.HAEnabled {
+		return fmt.Errorf("High Availability is not supported in JMX integrations")
+	}
 
 	return nil
 }
@@ -508,6 +513,9 @@ func (j *JMXFetch) ConfigureFromInstance(instance integration.Data) error {
 			j.JavaToolsJarPath = instanceConf.ToolsJarPath
 		}
 	}
+	if instanceConf.HAEnabled {
+		return fmt.Errorf("High Availability is not supported in JMX integrations")
+	}
 
 	return nil
 }

pkg/jmxfetch/jmxfetch_test.go

@@ -65,3 +65,18 @@ func TestConflictingInstanceInitJavaOptions(t *testing.T) {
 	require.Contains(t, j.JavaOptions, "Xmx200m")
 	require.NotContains(t, j.JavaOptions, "Xmx444m")
 }
+
+func TestCheckHAIsNotSupported(t *testing.T) {
+	j := NewJMXFetch(nil)
+
+	var configOne integration.Data = integration.Data("{\"ha_enabled\": true}")
+	var configTwo integration.Data = integration.Data("{\"ha_enabled\": true}")
+
+	err := j.ConfigureFromInitConfig(configOne)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "High Availability is not supported in JMX integrations")
+
+	err = j.ConfigureFromInstance(configTwo)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "High Availability is not supported in JMX integrations")
+}