remove global usage from docker core check

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
  }
 

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
+}

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,

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 {

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{}

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

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,13 +27,15 @@ func newUnbundledTransformer(hostname string, types []string, bundledTransformer
  hostname: hostname,
  collectedEventTypes: collectedEventTypes,
  bundledTransformer: bundledTransformer,
+ tagger: tagger,
  }
 }
 
 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,
  )

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)

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 {

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))