From fc852cbccc09598523907d1031de90a2e4d4ae41 Mon Sep 17 00:00:00 2001 From: Gustavo Caso Date: Fri, 18 Oct 2024 14:46:08 +0200 Subject: [PATCH] remove global usage from docker core check --- .../containers/docker/bundled_events.go | 7 +++-- .../corechecks/containers/docker/check.go | 26 +++++++++++++++---- .../containers/docker/check_test.go | 2 +- .../containers/docker/eventbundle.go | 6 +++-- .../corechecks/containers/docker/events.go | 3 +-- .../containers/docker/events_test.go | 6 ++++- .../containers/docker/unbundled_events.go | 6 +++-- .../docker/unbundled_events_test.go | 3 ++- .../corechecks/containers/docker/utils.go | 15 ----------- pkg/commonchecks/corechecks.go | 2 +- 10 files changed, 44 insertions(+), 32 deletions(-) diff --git a/pkg/collector/corechecks/containers/docker/bundled_events.go b/pkg/collector/corechecks/containers/docker/bundled_events.go index d0688b89be9a6..fc1c5aa525c79 100644 --- a/pkg/collector/corechecks/containers/docker/bundled_events.go +++ b/pkg/collector/corechecks/containers/docker/bundled_events.go @@ -8,6 +8,7 @@ package docker import ( + "github.com/DataDog/datadog-agent/comp/core/tagger" "github.com/DataDog/datadog-agent/pkg/metrics/event" "github.com/DataDog/datadog-agent/pkg/util/docker" "github.com/DataDog/datadog-agent/pkg/util/log" @@ -16,7 +17,7 @@ import ( // newBundledTransformer returns a transformer that bundles together docker // events from containers that share the same image. that's a behavior that no // longer makes sense, and we'd like to remove it in Agent 8. -func newBundledTransformer(hostname string, types []string) eventTransformer { +func newBundledTransformer(hostname string, types []string, tagger tagger.Component) eventTransformer { filteredEventTypes := make(map[string]struct{}, len(types)) for _, t := range types { filteredEventTypes[t] = struct{}{} @@ -25,12 +26,14 @@ func newBundledTransformer(hostname string, types []string) eventTransformer { return &bundledTransformer{ hostname: hostname, filteredEventTypes: filteredEventTypes, + tagger: tagger, } } type bundledTransformer struct { hostname string filteredEventTypes map[string]struct{} + tagger tagger.Component } func (t *bundledTransformer) Transform(events []*docker.ContainerEvent) ([]event.Event, []error) { @@ -67,7 +70,7 @@ func (t *bundledTransformer) aggregateEvents(events []*docker.ContainerEvent) ma bundle, found := eventsByImage[event.ImageName] if !found { - bundle = newDockerEventBundler(event.ImageName) + bundle = newDockerEventBundler(event.ImageName, t.tagger) eventsByImage[event.ImageName] = bundle } diff --git a/pkg/collector/corechecks/containers/docker/check.go b/pkg/collector/corechecks/containers/docker/check.go index 1fea8ba33f979..03543778c9312 100644 --- a/pkg/collector/corechecks/containers/docker/check.go +++ b/pkg/collector/corechecks/containers/docker/check.go @@ -66,18 +66,20 @@ type DockerCheck struct { okExitCodes map[int]struct{} collectContainerSizeCounter uint64 store workloadmeta.Component + tagger tagger.Component lastEventTime time.Time eventTransformer eventTransformer } // Factory returns a new docker corecheck factory -func Factory(store workloadmeta.Component) optional.Option[func() check.Check] { +func Factory(store workloadmeta.Component, tagger tagger.Component) optional.Option[func() check.Check] { return optional.NewOption(func() check.Check { return &DockerCheck{ CheckBase: core.NewCheckBase(CheckName), instance: &DockerConfig{}, store: store, + tagger: tagger, } }) } @@ -118,11 +120,12 @@ func (d *DockerCheck) Configure(senderManager sender.SenderManager, _ uint64, co d.dockerHostname, // Don't bundle events that are unbundled already. append(filteredEventTypes, d.instance.CollectedEventTypes...), + d.tagger, ) } - d.eventTransformer = newUnbundledTransformer(d.dockerHostname, d.instance.CollectedEventTypes, bundledTransformer) + d.eventTransformer = newUnbundledTransformer(d.dockerHostname, d.instance.CollectedEventTypes, bundledTransformer, d.tagger) } else { - d.eventTransformer = newBundledTransformer(d.dockerHostname, filteredEventTypes) + d.eventTransformer = newBundledTransformer(d.dockerHostname, filteredEventTypes, d.tagger) } d.containerFilter, err = containers.GetSharedMetricFilter() @@ -240,7 +243,7 @@ func (d *DockerCheck) runDockerCustom(sender sender.Sender, du docker.Client, ra isContainerExcluded := d.containerFilter.IsExcluded(annotations, containerName, resolvedImageName, rawContainer.Labels[kubernetes.CriContainerNamespaceLabel]) isContainerRunning := rawContainer.State == string(workloadmeta.ContainerStatusRunning) taggerEntityID := types.NewEntityID(types.ContainerID, rawContainer.ID).String() - tags, err := getImageTagsFromContainer(taggerEntityID, resolvedImageName, isContainerExcluded || !isContainerRunning) + tags, err := d.getImageTagsFromContainer(taggerEntityID, resolvedImageName, isContainerExcluded || !isContainerRunning) if err != nil { log.Debugf("Unable to fetch tags for image: %s, err: %v", rawContainer.ImageID, err) } else { @@ -263,7 +266,7 @@ func (d *DockerCheck) runDockerCustom(sender sender.Sender, du docker.Client, ra } // Send container size metrics - containerTags, err := tagger.Tag(taggerEntityID, types.HighCardinality) + containerTags, err := d.tagger.Tag(taggerEntityID, types.HighCardinality) if err != nil { log.Warnf("Unable to fetch tags for container: %s, err: %v", rawContainer.ID, err) } @@ -427,3 +430,16 @@ func (d *DockerCheck) setOkExitCodes() { // 143 is returned when docker sends a SIGTERM to stop a container. d.okExitCodes = map[int]struct{}{0: {}, 143: {}} } + +func (d *DockerCheck) getImageTagsFromContainer(taggerEntityID string, resolvedImageName string, isContainerExcluded bool) ([]string, error) { + if isContainerExcluded { + return getImageTags(resolvedImageName) + } + + containerTags, err := d.tagger.Tag(taggerEntityID, types.LowCardinality) + if err != nil { + return nil, err + } + + return containerTags, nil +} diff --git a/pkg/collector/corechecks/containers/docker/check_test.go b/pkg/collector/corechecks/containers/docker/check_test.go index 7f2c461a81137..66f5127178092 100644 --- a/pkg/collector/corechecks/containers/docker/check_test.go +++ b/pkg/collector/corechecks/containers/docker/check_test.go @@ -204,7 +204,7 @@ func TestDockerCustomPart(t *testing.T) { CollectVolumeCount: true, CollectEvent: true, }, - eventTransformer: newBundledTransformer("testhostname", []string{}), + eventTransformer: newBundledTransformer("testhostname", []string{}, fakeTagger), dockerHostname: "testhostname", containerFilter: &containers.Filter{ Enabled: true, diff --git a/pkg/collector/corechecks/containers/docker/eventbundle.go b/pkg/collector/corechecks/containers/docker/eventbundle.go index 6f67d03d7a29a..d0b36cd5e4285 100644 --- a/pkg/collector/corechecks/containers/docker/eventbundle.go +++ b/pkg/collector/corechecks/containers/docker/eventbundle.go @@ -31,14 +31,16 @@ type dockerEventBundle struct { maxTimestamp time.Time countByAction map[events.Action]int alertType event.AlertType + tagger tagger.Component } -func newDockerEventBundler(imageName string) *dockerEventBundle { +func newDockerEventBundler(imageName string, tagger tagger.Component) *dockerEventBundle { return &dockerEventBundle{ imageName: imageName, events: []*docker.ContainerEvent{}, countByAction: make(map[events.Action]int), alertType: event.AlertTypeInfo, + tagger: tagger, } } @@ -93,7 +95,7 @@ func (b *dockerEventBundle) toDatadogEvent(hostname string) (event.Event, error) for cid := range seenContainers { - tags, err := tagger.Tag(types.NewEntityID(types.ContainerID, cid).String(), types.HighCardinality) + tags, err := b.tagger.Tag(types.NewEntityID(types.ContainerID, cid).String(), types.HighCardinality) if err != nil { log.Debugf("no tags for %s: %s", cid, err) } else { diff --git a/pkg/collector/corechecks/containers/docker/events.go b/pkg/collector/corechecks/containers/docker/events.go index b492305983408..3a420e3995821 100644 --- a/pkg/collector/corechecks/containers/docker/events.go +++ b/pkg/collector/corechecks/containers/docker/events.go @@ -13,7 +13,6 @@ import ( "strconv" "time" - "github.com/DataDog/datadog-agent/comp/core/tagger" "github.com/DataDog/datadog-agent/comp/core/tagger/types" "github.com/DataDog/datadog-agent/pkg/aggregator/sender" "github.com/DataDog/datadog-agent/pkg/metrics/servicecheck" @@ -83,7 +82,7 @@ func (d *DockerCheck) reportExitCodes(events []*docker.ContainerEvent, sender se status = servicecheck.ServiceCheckCritical } - tags, err := tagger.Tag(types.NewEntityID(types.ContainerID, ev.ContainerID).String(), types.HighCardinality) + tags, err := d.tagger.Tag(types.NewEntityID(types.ContainerID, ev.ContainerID).String(), types.HighCardinality) if err != nil { log.Debugf("no tags for %s: %s", ev.ContainerID, err) tags = []string{} diff --git a/pkg/collector/corechecks/containers/docker/events_test.go b/pkg/collector/corechecks/containers/docker/events_test.go index 898918c6301a1..e93a492cdc146 100644 --- a/pkg/collector/corechecks/containers/docker/events_test.go +++ b/pkg/collector/corechecks/containers/docker/events_test.go @@ -13,6 +13,7 @@ import ( "github.com/docker/docker/api/types/events" "github.com/stretchr/testify/assert" + "github.com/DataDog/datadog-agent/comp/core/tagger/taggerimpl" "github.com/DataDog/datadog-agent/pkg/aggregator/mocksender" "github.com/DataDog/datadog-agent/pkg/metrics/event" "github.com/DataDog/datadog-agent/pkg/metrics/servicecheck" @@ -120,6 +121,9 @@ func TestReportExitCodes(t *testing.T) { } func TestAggregateEvents(t *testing.T) { + fakeTagger := taggerimpl.SetupFakeTagger(t) + defer fakeTagger.ResetTagger() + testCases := []struct { events []*docker.ContainerEvent filteredActions []string @@ -234,7 +238,7 @@ func TestAggregateEvents(t *testing.T) { } for _, tc := range testCases { t.Run("", func(t *testing.T) { - transformer := newBundledTransformer("test-host", tc.filteredActions).(*bundledTransformer) + transformer := newBundledTransformer("test-host", tc.filteredActions, fakeTagger).(*bundledTransformer) bundles := transformer.aggregateEvents(tc.events) for _, b := range bundles { // Strip underlying events to ease testing diff --git a/pkg/collector/corechecks/containers/docker/unbundled_events.go b/pkg/collector/corechecks/containers/docker/unbundled_events.go index ddb763e97f77f..a19362c1567de 100644 --- a/pkg/collector/corechecks/containers/docker/unbundled_events.go +++ b/pkg/collector/corechecks/containers/docker/unbundled_events.go @@ -17,7 +17,7 @@ import ( "github.com/DataDog/datadog-agent/pkg/util/log" ) -func newUnbundledTransformer(hostname string, types []string, bundledTransformer eventTransformer) eventTransformer { +func newUnbundledTransformer(hostname string, types []string, bundledTransformer eventTransformer, tagger tagger.Component) eventTransformer { collectedEventTypes := make(map[string]struct{}, len(types)) for _, t := range types { collectedEventTypes[t] = struct{}{} @@ -27,6 +27,7 @@ func newUnbundledTransformer(hostname string, types []string, bundledTransformer hostname: hostname, collectedEventTypes: collectedEventTypes, bundledTransformer: bundledTransformer, + tagger: tagger, } } @@ -34,6 +35,7 @@ type unbundledTransformer struct { hostname string collectedEventTypes map[string]struct{} bundledTransformer eventTransformer + tagger tagger.Component } func (t *unbundledTransformer) Transform(events []*docker.ContainerEvent) ([]event.Event, []error) { @@ -56,7 +58,7 @@ func (t *unbundledTransformer) Transform(events []*docker.ContainerEvent) ([]eve emittedEvents.Inc(string(alertType)) - tags, err := tagger.Tag( + tags, err := t.tagger.Tag( types.NewEntityID(types.ContainerID, ev.ContainerID).String(), types.HighCardinality, ) diff --git a/pkg/collector/corechecks/containers/docker/unbundled_events_test.go b/pkg/collector/corechecks/containers/docker/unbundled_events_test.go index 984f59c642297..125fd12785434 100644 --- a/pkg/collector/corechecks/containers/docker/unbundled_events_test.go +++ b/pkg/collector/corechecks/containers/docker/unbundled_events_test.go @@ -301,12 +301,13 @@ pokemon/azurill 1 top on test-host t.Run(tt.name, func(t *testing.T) { var eventTransformer eventTransformer = noopEventTransformer{} if tt.bundleUnspecifedEvents { - eventTransformer = newBundledTransformer(hostname, tt.filteredEventTypes) + eventTransformer = newBundledTransformer(hostname, tt.filteredEventTypes, fakeTagger) } transformer := newUnbundledTransformer( hostname, tt.collectedEventTypes, eventTransformer, + fakeTagger, ) evs, errs := transformer.Transform(incomingEvents) require.Nil(t, errs) diff --git a/pkg/collector/corechecks/containers/docker/utils.go b/pkg/collector/corechecks/containers/docker/utils.go index 500cf6cdde2d7..a514af5e1b753 100644 --- a/pkg/collector/corechecks/containers/docker/utils.go +++ b/pkg/collector/corechecks/containers/docker/utils.go @@ -12,8 +12,6 @@ import ( "github.com/docker/docker/api/types/events" - "github.com/DataDog/datadog-agent/comp/core/tagger" - "github.com/DataDog/datadog-agent/comp/core/tagger/types" workloadmeta "github.com/DataDog/datadog-agent/comp/core/workloadmeta/def" "github.com/DataDog/datadog-agent/pkg/collector/corechecks/containers/generic" "github.com/DataDog/datadog-agent/pkg/util/containers" @@ -30,19 +28,6 @@ func getProcessorFilter(legacyFilter *containers.Filter, store workloadmeta.Comp } } -func getImageTagsFromContainer(taggerEntityID string, resolvedImageName string, isContainerExcluded bool) ([]string, error) { - if isContainerExcluded { - return getImageTags(resolvedImageName) - } - - containerTags, err := tagger.Tag(taggerEntityID, types.LowCardinality) - if err != nil { - return nil, err - } - - return containerTags, nil -} - func getImageTags(imageName string) ([]string, error) { long, _, short, tag, err := pkgcontainersimage.SplitImageName(imageName) if err != nil { diff --git a/pkg/commonchecks/corechecks.go b/pkg/commonchecks/corechecks.go index f4719c58ba0e6..186d62760e20a 100644 --- a/pkg/commonchecks/corechecks.go +++ b/pkg/commonchecks/corechecks.go @@ -93,7 +93,7 @@ func RegisterChecks(store workloadmeta.Component, tagger tagger.Component, cfg c corecheckLoader.RegisterCheck(winproc.CheckName, winproc.Factory()) corecheckLoader.RegisterCheck(systemd.CheckName, systemd.Factory()) corecheckLoader.RegisterCheck(orchestrator.CheckName, orchestrator.Factory(store, cfg)) - corecheckLoader.RegisterCheck(docker.CheckName, docker.Factory(store)) + corecheckLoader.RegisterCheck(docker.CheckName, docker.Factory(store, tagger)) corecheckLoader.RegisterCheck(sbom.CheckName, sbom.Factory(store, cfg)) corecheckLoader.RegisterCheck(kubelet.CheckName, kubelet.Factory(store)) corecheckLoader.RegisterCheck(containerd.CheckName, containerd.Factory(store))