STAC-21039: Various unit test fixes

omnibus/config/projects/agent.rb

@@ -230,7 +230,7 @@
 dependency 'agent-dependencies'
 
 # Datadog agent
-# dependency 'datadog-agent'
+dependency 'datadog-agent'
 
 # System-probe
 if linux_target? && !heroku_target?

pkg/collector/corechecks/cluster/ksm/kubernetes_state_test.go

@@ -1482,7 +1482,7 @@ func TestKSMCheck_mergeLabelsMapper(t *testing.T) {
 			name:     "empty extra",
 			config:   &KSMConfig{LabelsMapper: map[string]string{"tar": "foo"}},
 			extra:    map[string]string{},
-			expected: map[string][]string{"tar": "foo"},
+			expected: map[string]string{"tar": "foo"},
 		},
 	}
 	for _, tt := range tests {

pkg/collector/corechecks/cluster/kubeapi/kubernetes_common.go

@@ -8,6 +8,7 @@ package kubeapi
 
 import (
 	"errors"
+	"github.com/DataDog/datadog-agent/pkg/aggregator/sender"
 	"github.com/DataDog/datadog-agent/pkg/autodiscovery/integration"
 	core "github.com/DataDog/datadog-agent/pkg/collector/corechecks"
 	"github.com/DataDog/datadog-agent/pkg/config"

pkg/collector/corechecks/cluster/kubeapi/kubernetes_event_mapper.go

@@ -161,32 +161,32 @@ func newKubernetesEventMapper(detector apiserver.OpenShiftDetector, clusterName
 
 var _ KubernetesEventMapperFactory = newKubernetesEventMapper // Compile-time check
 
-func (k *kubernetesEventMapper) mapKubernetesEvent(event *v1.Event) (event.Event, error) {
-	if err := checkEvent(event); err != nil {
+func (k *kubernetesEventMapper) mapKubernetesEvent(ev *v1.Event) (event.Event, error) {
+	if err := checkEvent(ev); err != nil {
 		return event.Event{}, err
 	}
 
 	// Map Category to event type
 	//
 
-	mEvent := metrics.Event{
-		Title:          fmt.Sprintf("%s - %s %s (%dx)", event.Reason, event.InvolvedObject.Name, event.InvolvedObject.Kind, event.Count),
-		Host:           getHostName(event, k.clusterName),
+	mEvent := event.Event{
+		Title:          fmt.Sprintf("%s - %s %s (%dx)", ev.Reason, ev.InvolvedObject.Name, ev.InvolvedObject.Kind, ev.Count),
+		Host:           getHostName(ev, k.clusterName),
 		SourceTypeName: k.sourceType,
-		Priority:       metrics.EventPriorityNormal,
-		AlertType:      getAlertType(event),
-		EventType:      event.Reason,
-		Ts:             getTimeStamp(event),
-		Tags:           k.getTags(event),
-		EventContext: &metrics.EventContext{
+		Priority:       event.EventPriorityNormal,
+		AlertType:      getAlertType(ev),
+		EventType:      ev.Reason,
+		Ts:             getTimeStamp(ev),
+		Tags:           k.getTags(ev),
+		EventContext: &event.EventContext{
 			Source:             k.sourceType,
-			Category:           string(k.getCategory(event)),
-			SourceIdentifier:   string(event.GetUID()),
-			ElementIdentifiers: k.externalIdentifierForInvolvedObject(event),
-			SourceLinks:        []metrics.SourceLink{},
+			Category:           string(k.getCategory(ev)),
+			SourceIdentifier:   string(ev.GetUID()),
+			ElementIdentifiers: k.externalIdentifierForInvolvedObject(ev),
+			SourceLinks:        []event.SourceLink{},
 			Data:               map[string]interface{}{},
 		},
-		Text: event.Message,
+		Text: ev.Message,
 	}
 
 	return mEvent, nil
@@ -220,33 +220,33 @@ func getHostName(event *v1.Event, clusterName string) string {
 
 var thrownCategoryWarnings sync.Map
 
-func (k *kubernetesEventMapper) getCategory(event *v1.Event) EventCategory {
-	if category, ok := k.eventCategoriesOverride[event.Reason]; ok {
+func (k *kubernetesEventMapper) getCategory(ev *v1.Event) EventCategory {
+	if category, ok := k.eventCategoriesOverride[ev.Reason]; ok {
 		return category
 	}
 
-	alertType := getAlertType(event)
-	if alertType == metrics.EventAlertTypeWarning || alertType == metrics.EventAlertTypeError {
+	alertType := getAlertType(ev)
+	if alertType == event.EventAlertTypeWarning || alertType == event.EventAlertTypeError {
 		return Alerts
 	}
 
-	if category, ok := DefaultEventCategoriesMap[event.Reason]; ok {
+	if category, ok := DefaultEventCategoriesMap[ev.Reason]; ok {
 		return category
 	}
-	if _, exists := thrownCategoryWarnings.LoadOrStore(event.Reason, true); !exists {
-		_ = log.Warnf("Kubernetes event has unknown reason '%s' found, categorising as 'Others'. Involved object: '%s/%s'", event.Reason, event.InvolvedObject.Kind, event.InvolvedObject.Name)
+	if _, exists := thrownCategoryWarnings.LoadOrStore(ev.Reason, true); !exists {
+		_ = log.Warnf("Kubernetes event has unknown reason '%s' found, categorising as 'Others'. Involved object: '%s/%s'", ev.Reason, ev.InvolvedObject.Kind, ev.InvolvedObject.Name)
 	}
 	return Others
 }
 
-func getAlertType(event *v1.Event) event.EventAlertType {
-	switch strings.ToLower(event.Type) {
+func getAlertType(ev *v1.Event) event.EventAlertType {
+	switch strings.ToLower(ev.Type) {
 	case "normal":
 		return event.EventAlertTypeInfo
 	case "warning":
 		return event.EventAlertTypeWarning
 	default:
-		log.Warnf("Unhandled kubernetes event type '%s', fallback to metrics.EventAlertTypeInfo", event.Type)
+		log.Warnf("Unhandled kubernetes event type '%s', fallback to metrics.EventAlertTypeInfo", ev.Type)
 		return event.EventAlertTypeInfo
 	}
 }

pkg/collector/corechecks/cluster/kubeapi/kubernetes_events.go

@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"github.com/DataDog/datadog-agent/pkg/aggregator/sender"
 	"github.com/DataDog/datadog-agent/pkg/util"
+	"github.com/DataDog/datadog-agent/pkg/util/hostname"
 	"strings"
 	"time"
 
@@ -154,7 +155,7 @@ func (k *EventsCheck) setDefaults() {
 
 // getClusterName retrieves the name of the cluster, if found
 func (k *EventsCheck) getClusterName() {
-	hostname, _ := util.GetHostname(context.TODO())
+	hostname, _ := hostname.Get(context.TODO())
 	if clusterName := clustername.GetClusterName(context.TODO(), hostname); clusterName != "" {
 		k.clusterName = clusterName
 	}

pkg/collector/corechecks/cluster/kubeapi/kubernetes_events_test.go

@@ -9,6 +9,7 @@ package kubeapi
 import (
 	"context"
 	"fmt"
+	"github.com/DataDog/datadog-agent/pkg/metrics/event"
 	"sort"
 	"testing"
 
@@ -23,7 +24,6 @@ import (
 	core "github.com/DataDog/datadog-agent/pkg/collector/corechecks"
 	"github.com/DataDog/datadog-agent/pkg/collector/corechecks/cluster/urn"
 	"github.com/DataDog/datadog-agent/pkg/config"
-	"github.com/DataDog/datadog-agent/pkg/metrics"
 	"github.com/DataDog/datadog-agent/pkg/util/kubernetes/apiserver"
 	"github.com/DataDog/datadog-agent/pkg/util/kubernetes/clustername"
 	"k8s.io/apimachinery/pkg/types"
@@ -94,14 +94,14 @@ func TestProcessBundledEvents(t *testing.T) {
 		ev2,
 	}
 	mocked := mocksender.NewMockSender(kubeAPIEventsCheck.ID())
-	mocked.On("Event", mock.AnythingOfType("metrics.Event"))
+	mocked.On("Event", mock.AnythingOfType("event.Event"))
 
 	kubeAPIEventsCheck.processEvents(mocked, newKubeEventsBundle)
 
 	// We are only expecting one bundle event.
 	// We need to check that the countByAction concatenated string contains the source events.
 	// As the order is not guaranteed we want to use contains.
-	res1 := (mocked.Calls[0].Arguments.Get(0)).(metrics.Event)
+	res1 := (mocked.Calls[0].Arguments.Get(0)).(event.Event)
 	assert.Contains(t, res1.Title, "Scheduled - dca-789976f5d7-2ljx6 Pod")
 	assert.Equal(t, "Activities", res1.EventContext.Category)
 	mocked.AssertNumberOfCalls(t, "Event", 2)
@@ -112,7 +112,7 @@ func TestProcessBundledEvents(t *testing.T) {
 		ev3,
 		ev4,
 	}
-	modifiedNewDatadogEvents := metrics.Event{
+	modifiedNewDatadogEvents := event.Event{
 		Title:    "Events from the machine-blue Node",
 		Text:     "%%% \n30 **MissingClusterDNS**: MountVolume.SetUp succeeded\n \n _Events emitted by the kubelet seen at " + time.Unix(709675200, 0).String() + "_ \n\n %%%",
 		Priority: "normal",
@@ -122,7 +122,7 @@ func TestProcessBundledEvents(t *testing.T) {
 		Ts:             709675200,
 		Host:           "machine-blue",
 		EventType:      "MissingClusterDNS",
-		EventContext: &metrics.EventContext{
+		EventContext: &event.EventContext{
 			Source:   "kubernetes",
 			Category: "Alerts",
 			ElementIdentifiers: []string{
@@ -132,7 +132,7 @@ func TestProcessBundledEvents(t *testing.T) {
 		},
 	}
 	mocked = mocksender.NewMockSender(kubeAPIEventsCheck.ID())
-	mocked.On("Event", mock.AnythingOfType("metrics.Event"))
+	mocked.On("Event", mock.AnythingOfType("event.Event"))
 
 	kubeAPIEventsCheck.processEvents(mocked, modifiedKubeEventsBundle)
 
@@ -141,15 +141,15 @@ func TestProcessBundledEvents(t *testing.T) {
 
 	// Test the hostname change when a cluster name is set
 	var testClusterName = "laika"
-	mockConfig := config.Mock()
-	mockConfig.Set("cluster_name", testClusterName)
+	mockConfig := config.Mock(nil)
+	mockConfig.SetWithoutSource("cluster_name", testClusterName)
 	clustername.ResetClusterName() // reset state as clustername was already read
 	// defer a reset of the state so that future hostname fetches are not impacted
-	defer mockConfig.Set("cluster_name", nil)
+	defer mockConfig.SetWithoutSource("cluster_name", nil)
 	defer clustername.ResetClusterName()
 	kubeAPIEventsCheck.clusterName = clustername.GetClusterName(context.TODO(), "")
 
-	modifiedNewDatadogEventsWithClusterName := metrics.Event{
+	modifiedNewDatadogEventsWithClusterName := event.Event{
 		Title:    "Events from the machine-blue Node",
 		Text:     "%%% \n30 **MissingClusterDNS**: MountVolume.SetUp succeeded\n \n _Events emitted by the kubelet seen at " + time.Unix(709675200, 0).String() + "_ \n\n %%%",
 		Priority: "normal",
@@ -159,7 +159,7 @@ func TestProcessBundledEvents(t *testing.T) {
 		Ts:             709675200,
 		Host:           "machine-blue-" + testClusterName,
 		EventType:      "MissingClusterDNS",
-		EventContext: &metrics.EventContext{
+		EventContext: &event.EventContext{
 			Source:   "kubernetes",
 			Category: "Alerts",
 			ElementIdentifiers: []string{
@@ -170,7 +170,7 @@ func TestProcessBundledEvents(t *testing.T) {
 	}
 
 	mocked = mocksender.NewMockSender(kubeAPIEventsCheck.ID())
-	mocked.On("Event", mock.AnythingOfType("metrics.Event"))
+	mocked.On("Event", mock.AnythingOfType("event.Event"))
 
 	kubeAPIEventsCheck.processEvents(mocked, modifiedKubeEventsBundle)
 
@@ -208,7 +208,7 @@ func TestProcessEvent(t *testing.T) {
 		ev1,
 	}
 	// 1 Scheduled:
-	newDatadogEvent := metrics.Event{
+	newDatadogEvent := event.Event{
 		Title:          "Events from the dca-789976f5d7-2ljx6 ReplicaSet",
 		Text:           "%%% \n2 **Scheduled**: Successfully assigned dca-789976f5d7-2ljx6 to ip-10-0-0-54\n \n _New events emitted by the default-scheduler seen at " + time.Unix(709662600000, 0).String() + "_ \n\n %%%",
 		Priority:       "normal",
@@ -217,7 +217,7 @@ func TestProcessEvent(t *testing.T) {
 		Ts:             709662600,
 		Host:           "",
 		EventType:      "Scheduled",
-		EventContext: &metrics.EventContext{
+		EventContext: &event.EventContext{
 			Source:   "kubernetes",
 			Category: "Activities",
 			ElementIdentifiers: []string{
@@ -226,7 +226,7 @@ func TestProcessEvent(t *testing.T) {
 			Data: map[string]interface{}{},
 		},
 	}
-	mocked.On("Event", mock.AnythingOfType("metrics.Event"))
+	mocked.On("Event", mock.AnythingOfType("event.Event"))
 	kubeAPIEventsCheck.processEvents(mocked, newKubeEventBundle)
 	mocked.AssertEvent(t, newDatadogEvent, 0)
 	mocked.AssertExpectations(t)
@@ -298,16 +298,16 @@ func TestProcessEventsType(t *testing.T) {
 		ev3,
 	}
 	mocked := mocksender.NewMockSender(kubeAPIEventsCheck.ID())
-	mocked.On("Event", mock.AnythingOfType("metrics.Event"))
+	mocked.On("Event", mock.AnythingOfType("event.Event"))
 
 	kubeAPIEventsCheck.processEvents(mocked, newKubeEventsBundle)
 	// We are only expecting two bundle events from the 3 kubernetes events because the event types differ.
 	// We need to check that the countByAction concatenated string contains the source events.
 	// As the order is not guaranteed we want to use contains.
 	calls := []string{
-		(mocked.Calls[0].Arguments.Get(0)).(metrics.Event).EventType,
-		(mocked.Calls[1].Arguments.Get(0)).(metrics.Event).EventType,
-		(mocked.Calls[2].Arguments.Get(0)).(metrics.Event).EventType,
+		(mocked.Calls[0].Arguments.Get(0)).(event.Event).EventType,
+		(mocked.Calls[1].Arguments.Get(0)).(event.Event).EventType,
+		(mocked.Calls[2].Arguments.Get(0)).(event.Event).EventType,
 	}
 
 	// The order of calls is random in processEvents because of the map eventsByObject
@@ -337,7 +337,7 @@ event_categories:
 	assert.NoError(t, err)
 
 	mockSender := mocksender.NewMockSender(evCheck.ID())
-	mockSender.On("Event", mock.AnythingOfType("metrics.Event"))
+	mockSender.On("Event", mock.AnythingOfType("event.Event"))
 
 	createEventShort := func(reason, alertType, message string) *v1.Event {
 		return createEvent(1, "default", "pearl-789976f5d7-2ljx6", "Pod", "e6417a7f-f566-11e7-9749-0e4863e1cbf4", "component1", "pearl.host", reason, message, 709662600, 709662600, alertType, "")
@@ -354,7 +354,7 @@ event_categories:
 
 	getCategoryForEventWithMessage := func(message string) string {
 		for _, call := range mockSender.Calls {
-			event := call.Arguments.Get(0).(metrics.Event)
+			event := call.Arguments.Get(0).(event.Event)
 			if event.Text == message {
 				return event.EventContext.Category
 			}

pkg/collector/corechecks/cluster/kubeapi/kubernetes_metrics.go

@@ -13,7 +13,8 @@ import (
 	"fmt"
 	"github.com/DataDog/datadog-agent/pkg/aggregator/sender"
 	"github.com/DataDog/datadog-agent/pkg/config"
-	"github.com/DataDog/datadog-agent/pkg/util"
+	"github.com/DataDog/datadog-agent/pkg/metrics/servicecheck"
+	"github.com/DataDog/datadog-agent/pkg/util/hostname"
 	"github.com/DataDog/datadog-agent/pkg/util/kubernetes/clustername"
 	"time"
 
@@ -23,7 +24,6 @@ import (
 	"github.com/DataDog/datadog-agent/pkg/autodiscovery/integration"
 	"github.com/DataDog/datadog-agent/pkg/collector/check"
 	core "github.com/DataDog/datadog-agent/pkg/collector/corechecks"
-	"github.com/DataDog/datadog-agent/pkg/metrics"
 	"github.com/DataDog/datadog-agent/pkg/util/kubernetes/apiserver"
 	"github.com/DataDog/datadog-agent/pkg/util/log"
 )
@@ -86,15 +86,15 @@ func KubernetesAPIMetricsFactory() check.Check {
 
 // getClusterName retrieves the name of the cluster, if found
 func (k *MetricsCheck) getClusterName() {
-	hostname, _ := util.GetHostname(context.TODO())
+	hostname, _ := hostname.Get(context.TODO())
 	if clusterName := clustername.GetClusterName(context.TODO(), hostname); clusterName != "" {
 		k.clusterName = clusterName
 	}
 }
 
 // Configure parses the check configuration and init the check.
-func (k *MetricsCheck) Configure(config, initConfig integration.Data, source string) error {
-	err := k.CommonConfigure(config, source)
+func (k *MetricsCheck) Configure(senderManager sender.SenderManager, integrationConfigDigest uint64, config, initConfig integration.Data, source string) error {
+	err := k.CommonConfigure(senderManager, integrationConfigDigest, config, initConfig, source)
 	if err != nil {
 		return err
 	}
@@ -179,7 +179,7 @@ func (k *MetricsCheck) parseComponentStatus(sender sender.Sender, componentsStat
 		}
 		tagComp := []string{fmt.Sprintf("component:%s", component.Name)}
 		for _, condition := range component.Conditions {
-			statusCheck := metrics.ServiceCheckUnknown
+			statusCheck := servicecheck.ServiceCheckUnknown
 			message := ""
 
 			// We only expect the Healthy condition. May change in the future. https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#typical-status-properties
@@ -190,10 +190,10 @@ func (k *MetricsCheck) parseComponentStatus(sender sender.Sender, componentsStat
 			// We only expect True, False and Unknown (default).
 			switch condition.Status {
 			case "True":
-				statusCheck = metrics.ServiceCheckOK
+				statusCheck = servicecheck.ServiceCheckOK
 				message = condition.Message
 			case "False":
-				statusCheck = metrics.ServiceCheckCritical
+				statusCheck = servicecheck.ServiceCheckCritical
 				message = condition.Error
 			}
 			sender.ServiceCheck(KubeControlPaneCheck, statusCheck, k.KubeAPIServerHostname, tagComp, message)

pkg/collector/corechecks/cluster/kubeapi/kubernetes_metrics_pods.go

@@ -9,7 +9,6 @@ package kubeapi
 
 import (
 	"fmt"
-	"github.com/DataDog/datadog-agent/pkg/aggregator"
 	"github.com/DataDog/datadog-agent/pkg/aggregator/sender"
 	"github.com/DataDog/datadog-agent/pkg/util/log"
 	v1 "k8s.io/api/core/v1"
@@ -53,7 +52,7 @@ func (k *MetricsCheck) podMetricsCollectionCheck() (pods []*v1.Pod, err error) {
 	return pods, nil
 }
 
-func (k *MetricsCheck) processPods(sender aggregator.Sender, pods []*v1.Pod) {
+func (k *MetricsCheck) processPods(sender sender.Sender, pods []*v1.Pod) {
 	log.Info("Running kubernetes pod metric collector - processPods...")
 
 	for _, pod := range pods {

pkg/collector/corechecks/cluster/kubeapi/kubernetes_topology.go

@@ -7,6 +7,7 @@
 package kubeapi
 
 import (
+	"github.com/DataDog/datadog-agent/pkg/aggregator/sender"
 	"github.com/DataDog/datadog-agent/pkg/util/kubernetes/apiserver"
 	"sync"
 	"time"
@@ -46,7 +47,7 @@ func warnDisabledResource(name string, additionalWarning string, isEnabled bool)
 
 // Configure parses the check configuration and init the check.
 func (t *TopologyCheck) Configure(senderManager sender.SenderManager, integrationConfigDigest uint64, config, initConfig integration.Data, source string) error {
-	err := t.ConfigureKubeAPICheck(senderManagerm, integrationConfigDigest, config, initConfig, source)
+	err := t.ConfigureKubeAPICheck(senderManager, integrationConfigDigest, config, initConfig, source)
 	if err != nil {
 		return err
 	}