Merge pull request #40 from kubescape/support-new-instanceID

integration with new instance ID

go.mod

@@ -3,18 +3,18 @@ module sniffer
 go 1.19
 
 require (
-	github.com/armosec/utils-k8s-go v0.0.12
+	github.com/armosec/utils-k8s-go v0.0.13
 	github.com/kubescape/go-logger v0.0.11
-	github.com/kubescape/k8s-interface v0.0.102
+	github.com/kubescape/k8s-interface v0.0.114
 	github.com/kubescape/storage v0.2.0
 	k8s.io/api v0.26.2
 	k8s.io/apimachinery v0.26.2
 	k8s.io/client-go v0.26.2
 )
 
 require (
-	github.com/armosec/armoapi-go v0.0.169 // indirect
-	github.com/armosec/utils-go v0.0.12 // indirect
+	github.com/armosec/armoapi-go v0.0.172 // indirect
+	github.com/armosec/utils-go v0.0.14 // indirect
 	github.com/cenkalti/backoff/v4 v4.2.0 // indirect
 	github.com/coreos/go-oidc v2.2.1+incompatible // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect

go.sum

@@ -43,12 +43,12 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/armosec/armoapi-go v0.0.169 h1:5X1rpKCwjG3UPTw6TLq2wSk14sfoyOqPDLb55bO7V9Y=
-github.com/armosec/armoapi-go v0.0.169/go.mod h1:xlW8dGq0vVzbuk+kDZqMQIkfU9P/iiiiDavoCIboqgI=
-github.com/armosec/utils-go v0.0.12 h1:NXkG/BhbSVAmTVXr0qqsK02CmxEiXuJyPmdTRcZ4jAo=
-github.com/armosec/utils-go v0.0.12/go.mod h1:F/K1mI/qcj7fNuJl7xktoCeHM83azOF0Zq6eC2WuPyU=
-github.com/armosec/utils-k8s-go v0.0.12 h1:u7kHSUp4PpvPP3hEaRXMbM0Vw23IyLhAzzE+2TW6Jkk=
-github.com/armosec/utils-k8s-go v0.0.12/go.mod h1:rPHiOaHefWa9ujspwvYYAp0uEbqGGyAMiNrFa/Gpp/8=
+github.com/armosec/armoapi-go v0.0.172 h1:B/wErPe2L9BTASUj/LAbo6N9g6l7O65bH+2e8vOvTeU=
+github.com/armosec/armoapi-go v0.0.172/go.mod h1:xlW8dGq0vVzbuk+kDZqMQIkfU9P/iiiiDavoCIboqgI=
+github.com/armosec/utils-go v0.0.14 h1:Q6HGxOyc5aPObgUM2FQpkYGXjj7/LSrUPkppFJGTexU=
+github.com/armosec/utils-go v0.0.14/go.mod h1:F/K1mI/qcj7fNuJl7xktoCeHM83azOF0Zq6eC2WuPyU=
+github.com/armosec/utils-k8s-go v0.0.13 h1:MzrRotrtZjpz4Yq1VRGbxDOfd6b5qRqZupzLnpj+W1A=
+github.com/armosec/utils-k8s-go v0.0.13/go.mod h1:rPHiOaHefWa9ujspwvYYAp0uEbqGGyAMiNrFa/Gpp/8=
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
@@ -225,8 +225,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kubescape/go-logger v0.0.11 h1:oucpq2S7+DT7O+UclG5IrmHado/tj6+IkYf9czVk/aY=
 github.com/kubescape/go-logger v0.0.11/go.mod h1:yGiKBJ2lhq/kxzY/MVYDREL9fLV3RGD6gv+UFjslaew=
-github.com/kubescape/k8s-interface v0.0.102 h1:FAsGstCcQv5kLT19PUbtdZayeT1huFgXJ+KrZUaTsb4=
-github.com/kubescape/k8s-interface v0.0.102/go.mod h1:McIx729bV395FOL3FWiv8vyT5V0F1TbcbTOCc+LS50A=
+github.com/kubescape/k8s-interface v0.0.114 h1:l7dmNP5uoDhbqkgNSMXugHULEb56yD25+QDQzj/syww=
+github.com/kubescape/k8s-interface v0.0.114/go.mod h1:/7Y8kdqcL5wLIHsPTuMg+EMV9D2iT/m4n57M/3uPnD4=
 github.com/kubescape/storage v0.2.0 h1:WZXy4Dyjf5ltEMtk0SOD9RFL1haS9ffFPGfs1gUV1aM=
 github.com/kubescape/storage v0.2.0/go.mod h1:sPE749pFNoxoskBn6JTpNQyguF2rv/u2kYqzRd3MvXw=
 github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
@@ -693,7 +693,7 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo=
+gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o=
 grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

pkg/conthandler/container_aggregator_test.go

@@ -11,14 +11,16 @@ import (
 	"time"
 
 	accumulator "sniffer/pkg/event_data_storage"
+
+	instanceidhandler "github.com/kubescape/k8s-interface/instanceidhandler/v1"
 )
 
 const (
 	RedisPodName                                     = "redis-64bd97b5fc-kvh7r"
 	RedisImageID                                     = "docker-pullable://redis@sha256:6a59f1cbb8d28ac484176d52c473494859a512ddba3ea62a547258cf16c9b3ae"
 	RedisContainerID                                 = "16248df36c67"
 	RedisWLID                                        = "wlid://cluster-test/namespace-any/deployment/redis"
-	RedisInstanceID                                  = "any"
+	RedisInstanceID                                  = "apiVersion-v1/namespace-any/kind-deployment/name-redis/containerName-redis"
 	NumberOfRedisEventInTheMockAfterFilterDuplicated = 73
 )
 
@@ -46,9 +48,15 @@ func TestContAggregator(t *testing.T) {
 		t.Fatalf("StartAccumulator failed with err %v", err)
 	}
 
+	RedisInstanceID := instanceidhandler.InstanceID{}
+	RedisInstanceID.SetAPIVersion("v1")
+	RedisInstanceID.SetNamespace("any")
+	RedisInstanceID.SetKind("deployment")
+	RedisInstanceID.SetName("redis")
+	RedisInstanceID.SetContainerName("redis")
 	containersEventChan := make(chan conthadlerV1.ContainerEventData, 50)
 	go func() {
-		containersEventChan <- *conthadlerV1.CreateNewContainerEvent(RedisImageID, RedisContainerID, RedisPodName, RedisWLID, RedisInstanceID, conthadlerV1.ContainerRunning)
+		containersEventChan <- *conthadlerV1.CreateNewContainerEvent(RedisImageID, RedisContainerID, RedisPodName, RedisWLID, &RedisInstanceID, conthadlerV1.ContainerRunning)
 	}()
 
 	event := <-containersEventChan

pkg/conthandler/container_main_handler.go

@@ -23,6 +23,11 @@ const (
 	StepEventAggregator = "StepEventAggregator"
 )
 
+var (
+	containerAlreadyExistError  = errors.New("container already exist")
+	containerHasTerminatedError = errors.New("container has terminated")
+)
+
 type supportedServices string
 
 type afterTimerActionsData struct {
@@ -90,7 +95,7 @@ func (ch *ContainerHandler) afterTimerActions() error {
 			}
 			if err = containerData.sbomClient.StoreFilterSBOM(containerData.event.GetInstanceIDHash()); err != nil {
 				if errors.Is(err, sbom.IsAlreadyExist()) {
-					logger.L().Info("SBOM already reported", []helpers.IDetails{helpers.String("container ID", afterTimerActionsData.containerID), helpers.String("container name", containerData.event.GetContainerName()), helpers.String("k8s resource", containerData.event.GetK8SWorkloadID())}...)
+					logger.L().Debug("SBOM already reported", []helpers.IDetails{helpers.String("container ID", afterTimerActionsData.containerID), helpers.String("container name", containerData.event.GetContainerName()), helpers.String("k8s resource", containerData.event.GetK8SWorkloadID())}...)
 				} else {
 					logger.L().Ctx(context.GetBackgroundContext()).Warning("failed to store filter SBOM", []helpers.IDetails{helpers.String("container ID", afterTimerActionsData.containerID), helpers.String("k8s resource", containerData.event.GetK8SWorkloadID()), helpers.Error(err)}...)
 				}
@@ -115,6 +120,9 @@ func (ch *ContainerHandler) startTimer(watchedContainer watchedContainerData, co
 		if err.Error() == accumulator.DropEventOccurred {
 			watchedContainer.snifferTicker.Stop()
 			err = fmt.Errorf("we have missed some kernel events, we are going to stop all current containers monitoring")
+		} else if errors.Is(err, containerHasTerminatedError) {
+			watchedContainer.snifferTicker.Stop()
+			logger.L().Debug("container has terminated", helpers.String("container ID", watchedContainer.event.GetContainerID()), helpers.String("container name", watchedContainer.event.GetContainerName()), helpers.String("k8s resources", watchedContainer.event.GetK8SWorkloadID()))
 		}
 	}
 
@@ -145,7 +153,7 @@ func (ch *ContainerHandler) startRelevancyProcess(contEvent v1.ContainerEventDat
 		go ch.getSBOM(contEvent)
 		err = ch.startTimer(watchedContainer, contEvent.GetContainerID())
 		if err != nil {
-			logger.L().Ctx(context.GetBackgroundContext()).Warning("timer of containerID stop before expected", helpers.String("container ID", contEvent.GetContainerID()), helpers.String("container name", contEvent.GetContainerName()), helpers.String("k8s resources", contEvent.GetK8SWorkloadID()), helpers.Error(err))
+			logger.L().Ctx(context.GetBackgroundContext()).Debug("container monitoring stop before expected", helpers.String("container ID", contEvent.GetContainerID()), helpers.String("container name", contEvent.GetContainerName()), helpers.String("k8s resources", contEvent.GetK8SWorkloadID()), helpers.Error(err))
 			err = watchedContainer.containerAggregator.StopAggregate()
 			if err != nil {
 				logger.L().Ctx(context.GetBackgroundContext()).Warning("we have failed to stop to aggregate data", helpers.String("container ID", contEvent.GetContainerID()), helpers.String("container name", contEvent.GetContainerName()), helpers.String("k8s resources", contEvent.GetK8SWorkloadID()))
@@ -176,11 +184,16 @@ func (ch *ContainerHandler) getSBOM(contEvent v1.ContainerEventData) {
 }
 
 func (ch *ContainerHandler) handleContainerRunningEvent(contEvent v1.ContainerEventData) error {
+	_, exist := ch.watchedContainers.Load(contEvent.GetContainerID())
+	if exist {
+		return containerAlreadyExistError
+	}
+	logger.L().Info("new container has loaded - start monitor it", []helpers.IDetails{helpers.String("ContainerID", contEvent.GetContainerID()), helpers.String("Container name", contEvent.GetContainerID()), helpers.String("k8s workload", contEvent.GetK8SWorkloadID())}...)
 	newWatchedContainer := watchedContainerData{
 		containerAggregator: CreateAggregator(getShortContainerID(contEvent.GetContainerID())),
 		snifferTicker:       createTicker(),
 		event:               contEvent,
-		sbomClient:          sbom.CreateSBOMStorageClient(ch.storageClient, contEvent.GetK8SWorkloadID(), contEvent.GetInstanceID()),
+		sbomClient:          sbom.CreateSBOMStorageClient(ch.storageClient, contEvent.GetInstanceID()),
 		syncChannel: map[string]chan error{
 			StepGetSBOM:         make(chan error, 10),
 			StepEventAggregator: make(chan error, 10),
@@ -191,10 +204,26 @@ func (ch *ContainerHandler) handleContainerRunningEvent(contEvent v1.ContainerEv
 	return nil
 }
 
+func (ch *ContainerHandler) handleContainerTerminatedEvent(contEvent v1.ContainerEventData) error {
+	watchedContainer, exist := ch.watchedContainers.Load(contEvent.GetContainerID())
+	if exist {
+		data, ok := watchedContainer.(watchedContainerData)
+		if !ok {
+			return fmt.Errorf("failed to stop container ID %s", contEvent.GetContainerID())
+		}
+		logger.L().Info("container has terminated - stop monitor it", []helpers.IDetails{helpers.String("ContainerID", contEvent.GetContainerID()), helpers.String("Container name", data.event.GetContainerName()), helpers.String("k8s workload", data.event.GetK8SWorkloadID())}...)
+		data.syncChannel[StepEventAggregator] <- containerHasTerminatedError
+	}
+	return nil
+}
+
 func (ch *ContainerHandler) handleNewContainerEvent(contEvent v1.ContainerEventData) error {
 	switch contEvent.GetContainerEventType() {
 	case v1.ContainerRunning:
 		return ch.handleContainerRunningEvent(contEvent)
+
+	case v1.ContainerDeleted:
+		return ch.handleContainerTerminatedEvent(contEvent)
 	}
 	return nil
 }
@@ -205,10 +234,11 @@ func (ch *ContainerHandler) StartMainHandler() error {
 
 	for {
 		contEvent := <-ch.containersEventChan
-		logger.L().Info("", []helpers.IDetails{helpers.String("new container has loaded", contEvent.GetContainerID()), helpers.String("ContainerID", contEvent.GetContainerID()), helpers.String("Container name", contEvent.GetContainerID()), helpers.String("k8s workload", contEvent.GetK8SWorkloadID())}...)
 		err := ch.handleNewContainerEvent(contEvent)
 		if err != nil {
-			logger.L().Ctx(context.GetBackgroundContext()).Warning("fail to handle new container", helpers.String("ContainerID", contEvent.GetContainerID()), helpers.String("Container name", contEvent.GetContainerID()), helpers.String("k8s workload", contEvent.GetK8SWorkloadID()), helpers.Error(err))
+			if !errors.Is(err, containerAlreadyExistError) {
+				logger.L().Ctx(context.GetBackgroundContext()).Warning("fail to handle new container", helpers.String("ContainerID", contEvent.GetContainerID()), helpers.String("Container name", contEvent.GetContainerID()), helpers.String("k8s workload", contEvent.GetK8SWorkloadID()), helpers.Error(err))
+			}
 		}
 	}
 }

pkg/conthandler/container_main_handler_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	instanceidhandler "github.com/kubescape/k8s-interface/instanceidhandler/v1"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/kubernetes/fake"
 )
@@ -61,7 +62,13 @@ func TestContMainHandler(t *testing.T) {
 	}
 	go contHandler.afterTimerActions()
 	go func() {
-		contHandler.containersEventChan <- *conthadlerV1.CreateNewContainerEvent(RedisImageID, RedisContainerIDContHandler, RedisPodName, RedisWLID, RedisInstanceID, conthadlerV1.ContainerRunning)
+		RedisInstanceID := instanceidhandler.InstanceID{}
+		RedisInstanceID.SetAPIVersion("v1")
+		RedisInstanceID.SetNamespace("any")
+		RedisInstanceID.SetKind("deployment")
+		RedisInstanceID.SetName("redis")
+		RedisInstanceID.SetContainerName("redis")
+		contHandler.containersEventChan <- *conthadlerV1.CreateNewContainerEvent(RedisImageID, RedisContainerIDContHandler, RedisPodName, RedisWLID, &RedisInstanceID, conthadlerV1.ContainerRunning)
 	}()
 
 	event := <-contHandler.containersEventChan

pkg/conthandler/container_watcher.go

@@ -13,6 +13,8 @@ import (
 	wlid "github.com/armosec/utils-k8s-go/wlid"
 	"github.com/kubescape/go-logger"
 	"github.com/kubescape/go-logger/helpers"
+	instanceidhandler "github.com/kubescape/k8s-interface/instanceidhandler"
+	instanceidhandlerV1 "github.com/kubescape/k8s-interface/instanceidhandler/v1"
 	k8sinterface "github.com/kubescape/k8s-interface/k8sinterface"
 	"github.com/kubescape/k8s-interface/workloadinterface"
 	core "k8s.io/api/core/v1"
@@ -80,6 +82,16 @@ func (client *ContainerClientK8SAPIServer) GenerateWLID(workload any, clusterNam
 	return w.GenerateWlid(clusterName)
 }
 
+func getInstanceID(instanceIDs []instanceidhandler.IInstanceID, name string) instanceidhandler.IInstanceID {
+	foundIndex := 0
+	for i := range instanceIDs {
+		if instanceIDs[i].GetContainerName() == name {
+			foundIndex = i
+		}
+	}
+	return instanceIDs[foundIndex]
+}
+
 func (containerWatcher *ContainerWatcher) parsePodData(pod *core.Pod, containerIndex int) (*conthandlerV1.ContainerEventData, error) {
 	pod.TypeMeta.Kind = "Pod"
 	podBytes, err := json.Marshal(pod)
@@ -104,10 +116,11 @@ func (containerWatcher *ContainerWatcher) parsePodData(pod *core.Pod, containerI
 		return nil, fmt.Errorf("WLID of parent workload is not in the right %s in namespace %s with error: %v", pod.GetName(), pod.GetNamespace(), err)
 	}
 
-	instanceID, err := conthandlerV1.CreateInstanceID(containerWatcher.ContainerClient.GetApiVersion(parentWorkload), containerWatcher.ContainerClient.GetResourceVersion(parentWorkload), parentWlid, pod.Status.ContainerStatuses[containerIndex].Name)
+	instanceIDs, err := instanceidhandlerV1.GenerateInstanceID(workload)
 	if err != nil {
 		return nil, fmt.Errorf("fail to create InstanceID to pod %s in namespace %s with error: %v", pod.GetName(), pod.GetNamespace(), err)
 	}
+	instanceID := getInstanceID(instanceIDs, pod.Status.ContainerStatuses[containerIndex].Name)
 	return conthandlerV1.CreateNewContainerEvent(pod.Status.ContainerStatuses[containerIndex].ImageID, pod.Status.ContainerStatuses[containerIndex].ContainerID, pod.GetName(), parentWlid, instanceID, conthandlerV1.ContainerRunning), nil
 }
 
@@ -139,7 +152,7 @@ func (containerWatcher *ContainerWatcher) StartWatchedOnContainers(containerEven
 			case watch.Modified:
 				for i := range pod.Status.ContainerStatuses {
 					if pod.Status.ContainerStatuses[i].Started != nil && *pod.Status.ContainerStatuses[i].Started {
-						logger.L().Info("container has started", helpers.String("namespace", pod.GetNamespace()), helpers.String("Pod name", pod.GetName()), helpers.String("ContainerID", pod.Status.ContainerStatuses[i].ContainerID), helpers.String("Container name", pod.Status.ContainerStatuses[i].Name))
+						logger.L().Debug("container has started", helpers.String("namespace", pod.GetNamespace()), helpers.String("Pod name", pod.GetName()), helpers.String("ContainerID", pod.Status.ContainerStatuses[i].ContainerID), helpers.String("Container name", pod.Status.ContainerStatuses[i].Name))
 						if pod.GetNamespace() == config.GetConfigurationConfigContext().GetNamespace() && pod.GetName() == config.GetConfigurationConfigContext().GetContainerName() {
 							continue
 						}
@@ -149,6 +162,10 @@ func (containerWatcher *ContainerWatcher) StartWatchedOnContainers(containerEven
 							continue
 						}
 						containerEventChannel <- *containerEventData
+					} else if pod.Status.ContainerStatuses[i].State.Terminated != nil {
+						logger.L().Debug("container has Terminated", helpers.String("namespace", pod.GetNamespace()), helpers.String("Pod name", pod.GetName()), helpers.String("ContainerID", pod.Status.ContainerStatuses[i].ContainerID), helpers.String("Container name", pod.Status.ContainerStatuses[i].Name))
+						containerEventData := conthandlerV1.CreateNewContainerEvent("", pod.Status.ContainerStatuses[i].ContainerID, "", "", &instanceidhandlerV1.InstanceID{}, conthandlerV1.ContainerDeleted)
+						containerEventChannel <- *containerEventData
 					}
 				}
 			}

pkg/conthandler/v1/container_handler_data.go

@@ -1,12 +1,10 @@
 package conthandler
 
 import (
-	"crypto/sha256"
-	"encoding/hex"
 	"fmt"
 	"strings"
 
-	wlid "github.com/armosec/utils-k8s-go/wlid"
+	instanceidhandler "github.com/kubescape/k8s-interface/instanceidhandler"
 )
 
 const (
@@ -21,11 +19,11 @@ type ContainerEventData struct {
 	containerID   string
 	containerName string
 	wlid          string
-	instanceID    string
+	instanceID    instanceidhandler.IInstanceID
 	eventType     ContainerEventType
 }
 
-func CreateNewContainerEvent(imageID, containerID, containerName, wlid, instanceID string, eventType ContainerEventType) *ContainerEventData {
+func CreateNewContainerEvent(imageID, containerID, containerName, wlid string, instanceID instanceidhandler.IInstanceID, eventType ContainerEventType) *ContainerEventData {
 	return &ContainerEventData{
 		imageID:       imageID,
 		containerID:   containerID,
@@ -64,20 +62,10 @@ func (event *ContainerEventData) GetImageID() string {
 	return event.imageID
 }
 
-func (event *ContainerEventData) GetInstanceID() string {
+func (event *ContainerEventData) GetInstanceID() instanceidhandler.IInstanceID {
 	return event.instanceID
 }
 
 func (event *ContainerEventData) GetInstanceIDHash() string {
-	hash := sha256.Sum256([]byte(event.instanceID))
-	str := hex.EncodeToString(hash[:])
-	return str
-}
-
-func CreateInstanceID(apiVersion, resourceVersion, wlidData, containerName string) (string, error) {
-	namespace := wlid.GetNamespaceFromWlid(wlidData)
-	kind := wlid.GetKindFromWlid(wlidData)
-	name := wlid.GetNameFromWlid(wlidData)
-
-	return "apiVersion-" + apiVersion + "/namespace-" + namespace + "/kind-" + kind + "/name-" + name + "/resourceVersion-" + resourceVersion + "/containerName-" + containerName, nil
+	return event.instanceID.GetHashed()
 }