You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@skywalking.apache.org by wu...@apache.org on 2022/05/15 05:57:43 UTC

[skywalking-rover] branch main updated: Update the process protocol (#29)

This is an automated email from the ASF dual-hosted git repository.

wusheng pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/skywalking-rover.git


The following commit(s) were added to refs/heads/main by this push:
     new 90c93c7  Update the process protocol (#29)
90c93c7 is described below

commit 90c93c706743aac1f5853b677730edae8cc32a2c
Author: mrproliu <74...@qq.com>
AuthorDate: Sun May 15 13:57:39 2022 +0800

    Update the process protocol (#29)
---
 .github/workflows/rover.yaml                       |   7 +-
 configs/rover_configs.yaml                         |   2 +
 docker/Dockerfile.build                            |   2 +-
 .../configuration/process_discovery/overview.md    |   1 +
 go.mod                                             |   3 +-
 go.sum                                             |   5 +-
 pkg/process/api/process.go                         |  16 +-
 pkg/process/config.go                              |   3 +
 pkg/process/finders/base/finder.go                 |   3 +
 pkg/process/finders/base/tool.go                   |  29 ++++
 pkg/process/finders/kubernetes/finder.go           |  55 +++++--
 pkg/process/finders/kubernetes/registry.go         |  30 +++-
 pkg/process/finders/manager.go                     |   4 +-
 pkg/process/finders/scanner/finder.go              |  17 +-
 pkg/process/finders/storage.go                     | 178 +++++++++------------
 pkg/process/module.go                              |   3 +-
 16 files changed, 228 insertions(+), 130 deletions(-)

diff --git a/.github/workflows/rover.yaml b/.github/workflows/rover.yaml
index 11c2784..68113bb 100644
--- a/.github/workflows/rover.yaml
+++ b/.github/workflows/rover.yaml
@@ -67,6 +67,7 @@ jobs:
   e2e-test:
     name: E2E test
     needs: [ docker ]
+    if: ${{ false }}  # disable for temporary, it would activate after OAP side finished
     runs-on: ubuntu-latest
     timeout-minutes: 60
     strategy:
@@ -145,6 +146,6 @@ jobs:
           if [[ ${{ needs.build.result }} != 'success' ]]; then
             exit -1
           fi
-          if [[ ${{ needs.e2e-test.result }} != 'success' ]]; then
-            exit -1
-          fi
\ No newline at end of file
+#          if [[ ${{ needs.e2e-test.result }} != 'success' ]]; then
+#            exit -1
+#          fi
\ No newline at end of file
diff --git a/configs/rover_configs.yaml b/configs/rover_configs.yaml
index f28b906..6a41c0a 100644
--- a/configs/rover_configs.yaml
+++ b/configs/rover_configs.yaml
@@ -37,6 +37,8 @@ core:
 process_discovery:
   # The period of report or keep alive process(second)
   heartbeat_period: ${ROVER_PROCESS_DISCOVERY_HEARTBEAT_PERIOD:20s}
+  # The agent sends the process properties to the backend every: heartbeart period * properties report period
+  properties_report_period: ${ROVER_PROCESS_DISCOVERY_PROPERTIES_REPORT_PERIOD:10}
   # Scan process from linux
   scanner:
     # The period to detect the process
diff --git a/docker/Dockerfile.build b/docker/Dockerfile.build
index 30991d8..a04305f 100644
--- a/docker/Dockerfile.build
+++ b/docker/Dockerfile.build
@@ -28,7 +28,7 @@ ENV CGO_ENABLED=0
 RUN VERSION=$VERSION make generate && make linux
 RUN mv /src/bin/skywalking-rover-${VERSION}-linux-amd64 /src/bin/skywalking-rover
 
-FROM scratch
+FROM alpine
 
 VOLUME /skywalking/configs
 
diff --git a/docs/en/setup/configuration/process_discovery/overview.md b/docs/en/setup/configuration/process_discovery/overview.md
index 9abb8ad..b3c574c 100644
--- a/docs/en/setup/configuration/process_discovery/overview.md
+++ b/docs/en/setup/configuration/process_discovery/overview.md
@@ -8,6 +8,7 @@ After the process upload is completed, the other modules could perform more oper
 | Name | Default | Environment Key | Description |
 |------|---------|-----------------|-------------|
 | process_discovery.heartbeat_period | 20s | ROVER_PROCESS_DISCOVERY_HEARTBEAT_PERIOD | The period of report or keep-alive process to the backend. |
+| process_discovery.properties_report_period | 10 | ROVER_PROCESS_DISCOVERY_PROPERTIES_REPORT_PERIOD | The agent sends the process properties to the backend every: heartbeart period * properties report period. |
 
 ## Process Detector
 
diff --git a/go.mod b/go.mod
index be11424..242a8d1 100644
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,7 @@ require (
 	github.com/cilium/ebpf v0.8.1
 	github.com/google/uuid v1.3.0
 	github.com/hashicorp/go-multierror v1.1.1
+	github.com/hashicorp/golang-lru v0.5.4
 	github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/sirupsen/logrus v1.8.1
@@ -16,7 +17,7 @@ require (
 	k8s.io/api v0.23.5
 	k8s.io/apimachinery v0.23.5
 	k8s.io/client-go v0.23.5
-	skywalking.apache.org/repo/goapi v0.0.0-20220421134447-34b3d2780c61
+	skywalking.apache.org/repo/goapi v0.0.0-20220513074115-4af2c2d37d2f
 )
 
 require (
diff --git a/go.sum b/go.sum
index b81cdcf..576eee9 100644
--- a/go.sum
+++ b/go.sum
@@ -265,6 +265,7 @@ github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b
 github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
 github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
@@ -939,5 +940,5 @@ sigs.k8s.io/structured-merge-diff/v4 v4.2.1 h1:bKCqE9GvQ5tiVHn5rfn1r+yao3aLQEaLz
 sigs.k8s.io/structured-merge-diff/v4 v4.2.1/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4=
 sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
-skywalking.apache.org/repo/goapi v0.0.0-20220421134447-34b3d2780c61 h1:MCjReXfgVVV/ay303rO104fQJFMGpbwwjXSOl0h82SY=
-skywalking.apache.org/repo/goapi v0.0.0-20220421134447-34b3d2780c61/go.mod h1:uWwwvhcwe2MD/nJCg0c1EE/eL6KzaBosLHDfMFoEJ30=
+skywalking.apache.org/repo/goapi v0.0.0-20220513074115-4af2c2d37d2f h1:InBru/3MVpcVoGPGRjY+A5LpAi992E37j6dCvvNqF/w=
+skywalking.apache.org/repo/goapi v0.0.0-20220513074115-4af2c2d37d2f/go.mod h1:uWwwvhcwe2MD/nJCg0c1EE/eL6KzaBosLHDfMFoEJ30=
diff --git a/pkg/process/api/process.go b/pkg/process/api/process.go
index 19bcaae..108bb87 100644
--- a/pkg/process/api/process.go
+++ b/pkg/process/api/process.go
@@ -17,7 +17,12 @@
 
 package api
 
-import "github.com/apache/skywalking-rover/pkg/tools/profiling"
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/apache/skywalking-rover/pkg/tools/profiling"
+)
 
 type ProcessDetectType int8
 
@@ -65,3 +70,12 @@ func (e *ProcessEntity) SameWith(other *ProcessEntity) bool {
 	return e.Layer == other.Layer && e.ServiceName == other.ServiceName && e.InstanceName == other.InstanceName &&
 		e.ProcessName == other.ProcessName
 }
+
+func (e *ProcessEntity) String() string {
+	marshal, err := json.Marshal(e)
+	if err != nil {
+		return fmt.Sprintf("layer: %s, service: %s, instance: %s, process: %s, labels: %v",
+			e.Labels, e.ServiceName, e.InstanceName, e.ProcessName, e.Labels)
+	}
+	return string(marshal)
+}
diff --git a/pkg/process/config.go b/pkg/process/config.go
index ebc39fe..24defe9 100644
--- a/pkg/process/config.go
+++ b/pkg/process/config.go
@@ -29,6 +29,9 @@ type Config struct {
 	// heartbeat the process list period
 	HeartbeatPeriod string `mapstructure:"heartbeat_period"`
 
+	// sends properties to the backend period
+	PropertiesReportPeriod int `mapstructure:"properties_report_period"`
+
 	// Scanner process from Linux
 	Scanner *scanner.Config `mapstructure:"scanner"`
 
diff --git a/pkg/process/finders/base/finder.go b/pkg/process/finders/base/finder.go
index 29733f6..d1edefa 100644
--- a/pkg/process/finders/base/finder.go
+++ b/pkg/process/finders/base/finder.go
@@ -20,6 +20,7 @@ package base
 import (
 	"context"
 
+	commonv3 "skywalking.apache.org/repo/goapi/collect/common/v3"
 	v3 "skywalking.apache.org/repo/goapi/collect/ebpf/profiling/process/v3"
 
 	"github.com/apache/skywalking-rover/pkg/module"
@@ -46,6 +47,8 @@ type ProcessFinder interface {
 
 	// BuildEBPFProcess is transform the process entity as backend protocol data
 	BuildEBPFProcess(ctx *BuildEBPFProcessContext, process DetectedProcess) *v3.EBPFProcessProperties
+	// BuildNecessaryProperties is getting minimize necessary properties when keep alive
+	BuildNecessaryProperties(process DetectedProcess) []*commonv3.KeyStringValuePair
 	// ParseProcessId is means how to read the process id receive from backend
 	ParseProcessID(process DetectedProcess, downstream *v3.EBPFProcessDownstream) string
 }
diff --git a/pkg/process/finders/base/tool.go b/pkg/process/finders/base/tool.go
index 5d79e42..408693c 100644
--- a/pkg/process/finders/base/tool.go
+++ b/pkg/process/finders/base/tool.go
@@ -19,7 +19,12 @@ package base
 
 import (
 	"fmt"
+	"reflect"
+	"sort"
 
+	v3 "skywalking.apache.org/repo/goapi/collect/ebpf/profiling/process/v3"
+
+	"github.com/apache/skywalking-rover/pkg/process/api"
 	"github.com/apache/skywalking-rover/pkg/tools"
 	"github.com/apache/skywalking-rover/pkg/tools/host"
 	"github.com/apache/skywalking-rover/pkg/tools/path"
@@ -53,3 +58,27 @@ func tryToFindFileExecutePath(ps *process.Process) string {
 	}
 	return ""
 }
+
+func EntityIsSameWithProtocol(processEntity *api.ProcessEntity, protocolEntity *v3.EBPFProcessEntityMetadata) bool {
+	if processEntity == nil || protocolEntity == nil {
+		return false
+	}
+
+	if !reflect.DeepEqual(sortLabelArray(processEntity.Labels), sortLabelArray(protocolEntity.Labels)) {
+		return false
+	}
+	return processEntity.Layer == protocolEntity.Layer &&
+		processEntity.ServiceName == protocolEntity.ServiceName &&
+		processEntity.InstanceName == protocolEntity.InstanceName &&
+		processEntity.ProcessName == protocolEntity.ProcessName
+}
+
+func sortLabelArray(a []string) []string {
+	if a == nil {
+		return make([]string, 0)
+	}
+	sort.SliceStable(a, func(i, j int) bool {
+		return a[i] > a[j]
+	})
+	return a
+}
diff --git a/pkg/process/finders/kubernetes/finder.go b/pkg/process/finders/kubernetes/finder.go
index d4ba96b..f04897c 100644
--- a/pkg/process/finders/kubernetes/finder.go
+++ b/pkg/process/finders/kubernetes/finder.go
@@ -26,6 +26,8 @@ import (
 	"strings"
 	"time"
 
+	lru "github.com/hashicorp/golang-lru"
+
 	commonv3 "skywalking.apache.org/repo/goapi/collect/common/v3"
 
 	"github.com/shirou/gopsutil/process"
@@ -50,10 +52,11 @@ type ProcessFinder struct {
 	conf *Config
 
 	// runtime
-	manager   base.ProcessManager
-	ctx       context.Context
-	cancelCtx context.CancelFunc
-	stopChan  chan struct{}
+	manager      base.ProcessManager
+	ctx          context.Context
+	cancelCtx    context.CancelFunc
+	stopChan     chan struct{}
+	processCache *lru.Cache
 
 	// k8s clients
 	k8sConfig *rest.Config
@@ -77,6 +80,11 @@ func (f *ProcessFinder) Init(ctx context.Context, conf base.FinderBaseConfig, ma
 	f.stopChan = make(chan struct{}, 1)
 	f.registry = NewRegistry(f.cli, f.namespaces, f.conf.NodeName)
 	f.manager = manager
+	cache, err := lru.New(5000)
+	if err != nil {
+		return err
+	}
+	f.processCache = cache
 
 	return nil
 }
@@ -146,6 +154,19 @@ func (f *ProcessFinder) analyzeProcesses() error {
 
 	result := make([]base.DetectedProcess, 0)
 	for _, p := range processes {
+		createTime, err := p.CreateTime()
+		if err != nil {
+			continue
+		}
+		processCahceKey := fmt.Sprintf("%d_%d", p.Pid, createTime)
+		cachedProcesses, exist := f.processCache.Get(processCahceKey)
+		if exist {
+			for _, pro := range cachedProcesses.([]*Process) {
+				result = append(result, pro)
+			}
+			continue
+		}
+
 		cgroup, err := f.getProcessCGroup(p.Pid)
 		if err != nil {
 			continue
@@ -166,6 +187,7 @@ func (f *ProcessFinder) analyzeProcesses() error {
 		for _, pro := range ps {
 			result = append(result, pro)
 		}
+		f.processCache.Add(processCahceKey, ps)
 	}
 
 	if len(result) > 0 {
@@ -264,6 +286,15 @@ func (f *ProcessFinder) ValidateProcessIsSame(p1, p2 base.DetectedProcess) bool
 	return p1.Pid() == p2.Pid() && k1.cmd == k2.cmd && p1.Entity().SameWith(p2.Entity())
 }
 
+func (f *ProcessFinder) BuildNecessaryProperties(ps base.DetectedProcess) []*commonv3.KeyStringValuePair {
+	return []*commonv3.KeyStringValuePair{
+		{
+			Key:   "support_ebpf_profiling",
+			Value: strconv.FormatBool(ps.ProfilingStat() != nil),
+		},
+	}
+}
+
 func (f *ProcessFinder) BuildEBPFProcess(ctx *base.BuildEBPFProcessContext, ps base.DetectedProcess) *v3.EBPFProcessProperties {
 	k8sProcess := &v3.EBPFKubernetesProcessMetadata{}
 	k8sProcess.Pid = ps.Pid()
@@ -283,6 +314,14 @@ func (f *ProcessFinder) BuildEBPFProcess(ctx *base.BuildEBPFProcessContext, ps b
 			Key:   "container_ip",
 			Value: ps.(*Process).podContainer.Pod.Status.PodIP,
 		},
+		{
+			Key:   "container_name",
+			Value: ps.(*Process).podContainer.ContainerSpec.Name,
+		},
+		{
+			Key:   "pod_name",
+			Value: ps.(*Process).podContainer.Pod.Name,
+		},
 		{
 			Key:   "pid",
 			Value: strconv.FormatInt(int64(ps.Pid()), 10),
@@ -291,11 +330,8 @@ func (f *ProcessFinder) BuildEBPFProcess(ctx *base.BuildEBPFProcessContext, ps b
 			Key:   "command_line",
 			Value: ps.(*Process).cmd,
 		},
-		{
-			Key:   "support_ebpf_profiling",
-			Value: strconv.FormatBool(ps.ProfilingStat() != nil),
-		},
 	}
+	k8sProcess.Properties = append(k8sProcess.Properties, f.BuildNecessaryProperties(ps)...)
 	properties := &v3.EBPFProcessProperties{Metadata: &v3.EBPFProcessProperties_K8SProcess{
 		K8SProcess: k8sProcess,
 	}}
@@ -306,7 +342,8 @@ func (f *ProcessFinder) ParseProcessID(ps base.DetectedProcess, downstream *v3.E
 	if downstream.GetK8SProcess() == nil {
 		return ""
 	}
-	if ps.Pid() == downstream.GetK8SProcess().GetPid() {
+	if ps.Pid() == downstream.GetK8SProcess().GetPid() &&
+		base.EntityIsSameWithProtocol(ps.Entity(), downstream.GetK8SProcess().GetEntityMetadata()) {
 		return downstream.GetProcessId()
 	}
 	return ""
diff --git a/pkg/process/finders/kubernetes/registry.go b/pkg/process/finders/kubernetes/registry.go
index 88c05db..eaaa0f0 100644
--- a/pkg/process/finders/kubernetes/registry.go
+++ b/pkg/process/finders/kubernetes/registry.go
@@ -18,6 +18,7 @@
 package kubernetes
 
 import (
+	"strings"
 	"time"
 
 	"k8s.io/apimachinery/pkg/labels"
@@ -73,7 +74,10 @@ func (r *Registry) BuildPodContainers() map[string]*PodContainer {
 		for _, p := range list {
 			analyzeContainers := AnalyzeContainers(p.(*v1.Pod), r)
 			for _, c := range analyzeContainers {
-				containers[c.CGroupID()] = c
+				id := c.CGroupID()
+				if id != "" {
+					containers[id] = c
+				}
 			}
 		}
 	}
@@ -100,7 +104,15 @@ func (r *Registry) recomposePodServiceName() {
 				}
 
 				if labels.Set(service.Spec.Selector).AsSelector().Matches(labels.Set(pod.ObjectMeta.Labels)) {
-					result[pod.Namespace+"_"+pod.Name] = service.Name
+					// if multiple service selector matches the same pod
+					// then must choose one by same logical
+					existing := result[pod.Namespace+"_"+pod.Name]
+					if existing != "" {
+						existing = chooseServiceName(existing, service.Name)
+					} else {
+						existing = service.Name
+					}
+					result[pod.Namespace+"_"+pod.Name] = existing
 				}
 			}
 		}
@@ -108,6 +120,20 @@ func (r *Registry) recomposePodServiceName() {
 	r.podServiceNameCache = result
 }
 
+func chooseServiceName(a, b string) string {
+	// short name
+	if len(a) < len(b) {
+		return a
+	} else if len(a) > len(b) {
+		return b
+	}
+	// ascii compare
+	if strings.Compare(a, b) < 0 {
+		return a
+	}
+	return b
+}
+
 func (r *Registry) OnAdd(_ interface{}) {
 	r.recomposePodServiceName()
 }
diff --git a/pkg/process/finders/manager.go b/pkg/process/finders/manager.go
index 1787cf5..5b2da11 100644
--- a/pkg/process/finders/manager.go
+++ b/pkg/process/finders/manager.go
@@ -48,7 +48,7 @@ type ProcessManagerWithFinder struct {
 }
 
 func NewProcessManager(ctx context.Context, moduleManager *module.Manager,
-	reportInterval time.Duration, configs ...base.FinderBaseConfig) (*ProcessManager, error) {
+	reportInterval time.Duration, propertiesReportFactor int, configs ...base.FinderBaseConfig) (*ProcessManager, error) {
 	// locate all finders
 	confinedFinders := make(map[base.FinderBaseConfig]base.ProcessFinder)
 	fsList := make([]base.ProcessFinder, 0)
@@ -65,7 +65,7 @@ func NewProcessManager(ctx context.Context, moduleManager *module.Manager,
 	}
 
 	// start new storage
-	storage, err := NewProcessStorage(ctx, moduleManager, reportInterval, fsList)
+	storage, err := NewProcessStorage(ctx, moduleManager, reportInterval, propertiesReportFactor, fsList)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/process/finders/scanner/finder.go b/pkg/process/finders/scanner/finder.go
index 768586f..758171c 100644
--- a/pkg/process/finders/scanner/finder.go
+++ b/pkg/process/finders/scanner/finder.go
@@ -112,22 +112,29 @@ func (p *ProcessFinder) BuildEBPFProcess(ctx *base.BuildEBPFProcessContext, ps b
 			Key:   "command_line",
 			Value: ps.(*Process).cmd,
 		},
-		{
-			Key:   "support_ebpf_profiling",
-			Value: strconv.FormatBool(ps.ProfilingStat() != nil),
-		},
 	}
+	hostProcess.Properties = append(hostProcess.Properties, p.BuildNecessaryProperties(ps)...)
 	properties := &v3.EBPFProcessProperties{Metadata: &v3.EBPFProcessProperties_HostProcess{
 		HostProcess: hostProcess,
 	}}
 	return properties
 }
 
+func (p *ProcessFinder) BuildNecessaryProperties(ps base.DetectedProcess) []*commonv3.KeyStringValuePair {
+	return []*commonv3.KeyStringValuePair{
+		{
+			Key:   "support_ebpf_profiling",
+			Value: strconv.FormatBool(ps.ProfilingStat() != nil),
+		},
+	}
+}
+
 func (p *ProcessFinder) ParseProcessID(ps base.DetectedProcess, downstream *v3.EBPFProcessDownstream) string {
 	if downstream.GetHostProcess() == nil {
 		return ""
 	}
-	if ps.Pid() == downstream.GetHostProcess().GetPid() {
+	if ps.Pid() == downstream.GetHostProcess().GetPid() &&
+		base.EntityIsSameWithProtocol(ps.Entity(), downstream.GetHostProcess().GetEntityMetadata()) {
 		return downstream.ProcessId
 	}
 	return ""
diff --git a/pkg/process/finders/storage.go b/pkg/process/finders/storage.go
index 58704ac..3fd53a2 100644
--- a/pkg/process/finders/storage.go
+++ b/pkg/process/finders/storage.go
@@ -20,6 +20,7 @@ package finders
 import (
 	"context"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/hashicorp/go-multierror"
@@ -34,14 +35,16 @@ import (
 )
 
 type ProcessStorage struct {
-	processes map[int32]*processesWrapper
+	processes map[api.ProcessDetectType][]*ProcessContext
 	mutex     sync.Mutex
 
 	// working with backend
-	reportInterval time.Duration
-	roverID        string
-	processClient  v3.EBPFProcessServiceClient
-	finders        map[api.ProcessDetectType]base.ProcessFinder
+	reportInterval         time.Duration
+	propertiesReportFactor int
+	roverID                string
+	processClient          v3.EBPFProcessServiceClient
+	finders                map[api.ProcessDetectType]base.ProcessFinder
+	reportedCount          int64
 
 	// report context
 	ctx    context.Context
@@ -49,8 +52,8 @@ type ProcessStorage struct {
 }
 
 func NewProcessStorage(ctx context.Context, moduleManager *module.Manager,
-	reportInterval time.Duration, finderList []base.ProcessFinder) (*ProcessStorage, error) {
-	data := make(map[int32]*processesWrapper)
+	reportInterval time.Duration, propertiesReportFactor int, finderList []base.ProcessFinder) (*ProcessStorage, error) {
+	data := make(map[api.ProcessDetectType][]*ProcessContext)
 	// working with core module
 	coreOperator := moduleManager.FindModule(core.ModuleName).(core.Operator)
 	roverID := coreOperator.InstanceID()
@@ -62,13 +65,15 @@ func NewProcessStorage(ctx context.Context, moduleManager *module.Manager,
 		fs[f.DetectType()] = f
 	}
 	return &ProcessStorage{
-		processes:      data,
-		reportInterval: reportInterval,
-		roverID:        roverID,
-		processClient:  processClient,
-		finders:        fs,
-		ctx:            ctx,
-		cancel:         cancel,
+		processes:              data,
+		reportInterval:         reportInterval,
+		propertiesReportFactor: propertiesReportFactor,
+		reportedCount:          0,
+		roverID:                roverID,
+		processClient:          processClient,
+		finders:                fs,
+		ctx:                    ctx,
+		cancel:                 cancel,
 	}, nil
 }
 
@@ -104,8 +109,8 @@ func (s *ProcessStorage) reportAllProcesses() error {
 	// build process list(wait report or keep alive)
 	waitReportProcesses := make([]*ProcessContext, 0)
 	keepAliveProcesses := make([]*ProcessContext, 0)
-	for _, wrapper := range s.processes {
-		for _, p := range wrapper.processes {
+	for _, finderProcesses := range s.processes {
+		for _, p := range finderProcesses {
 			if p.syncStatus == NotReport {
 				waitReportProcesses = append(waitReportProcesses, p)
 			} else if p.syncStatus == ReportSuccess {
@@ -114,7 +119,13 @@ func (s *ProcessStorage) reportAllProcesses() error {
 		}
 	}
 
-	// process with backend
+	// if rover should report the properties, then need to force remove all keep alive processes to report
+	shouldReportProperties := atomic.AddInt64(&s.reportedCount, 1)%int64(s.propertiesReportFactor) == 0
+	if shouldReportProperties {
+		log.Infof("detection has reached the properties report factor, forced to report all processes properties")
+		waitReportProcesses = append(waitReportProcesses, keepAliveProcesses...)
+		keepAliveProcesses = make([]*ProcessContext, 0)
+	}
 	var result error
 	if err := s.processesReport(waitReportProcesses); err != nil {
 		result = multierror.Append(result, err)
@@ -133,18 +144,28 @@ func (s *ProcessStorage) processesKeepAlive(waitKeepAliveProcess []*ProcessConte
 
 	processIDList := make([]*v3.EBPFProcessPingPkg, 0)
 	for _, ps := range waitKeepAliveProcess {
-		if ps.id != "" {
-			processIDList = append(processIDList, &v3.EBPFProcessPingPkg{EntityMetadata: &v3.EBPFProcessEntityMetadata{
+		if ps.id == "" {
+			log.Warnf("the process id is not found before keep alive, need to report, pid: %d, process name: %s",
+				ps.Pid(), ps.Entity().ProcessName)
+			ps.syncStatus = NotReport
+			continue
+		}
+		processIDList = append(processIDList, &v3.EBPFProcessPingPkg{
+			EntityMetadata: &v3.EBPFProcessEntityMetadata{
 				Layer:        ps.Entity().Layer,
 				ServiceName:  ps.Entity().ServiceName,
 				InstanceName: ps.Entity().InstanceName,
 				ProcessName:  ps.Entity().ProcessName,
 				Labels:       ps.Entity().Labels,
-			}})
-		}
+			},
+			Properties: s.finders[ps.detectType].BuildNecessaryProperties(ps.detectProcess),
+		})
 	}
 
-	_, err := s.processClient.KeepAlive(s.ctx, &v3.EBPFProcessPingPkgList{Processes: processIDList})
+	_, err := s.processClient.KeepAlive(s.ctx, &v3.EBPFProcessPingPkgList{
+		EbpfAgentID: s.roverID,
+		Processes:   processIDList,
+	})
 	return err
 }
 
@@ -164,17 +185,15 @@ func (s *ProcessStorage) processesReport(waitReportProcesses []*ProcessContext)
 		return err
 	}
 
-	processIDBeenUsed := make(map[string]bool)
 	for _, waitProcess := range waitReportProcesses {
 		found := false
 		for _, reportedProcess := range processes.GetProcesses() {
 			id := s.finders[waitProcess.DetectType()].ParseProcessID(waitProcess.detectProcess, reportedProcess)
-			if id == "" || processIDBeenUsed[id] {
+			if id == "" {
 				continue
 			}
 
 			s.updateProcessToUploadSuccess(waitProcess, id)
-			processIDBeenUsed[id] = true
 			found = true
 			break
 		}
@@ -190,75 +209,41 @@ func (s *ProcessStorage) SyncAllProcessInFinder(finder api.ProcessDetectType, pr
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	pidToProcess := make(map[int32]map[base.DetectedProcess]bool)
-	for _, ps := range processes {
-		samePidProcesses := pidToProcess[ps.Pid()]
-		if samePidProcesses == nil {
-			samePidProcesses = make(map[base.DetectedProcess]bool)
-			pidToProcess[ps.Pid()] = samePidProcesses
-		}
-		samePidProcesses[ps] = false
-	}
-
-	// for each all process in the manager
-	for pid, managedProcesses := range s.processes {
-		needToSyncProcesses := pidToProcess[pid]
-		// remove it from the list of need to sync
-		delete(pidToProcess, pid)
-
-		// The process to be synchronized is not found in all process list
-		// And this process is same with finder type
-		// So we need to remove this process
-		if needToSyncProcesses == nil {
-			if managedProcesses.deleteWithSameFinder(finder) {
-				delete(s.processes, pid)
-			}
-			continue
-		}
-
-		// build result for the pid
-		result := make([]*ProcessContext, 0)
+	newProcesses := make([]*ProcessContext, 0)
 
-		// find out all need to be update process
-		for _, p := range managedProcesses.processes {
-			// if in difference detect type, keep the process data
-			if p.DetectType() != finder {
-				result = append(result, p)
-				continue
-			}
+	existingProcesses := s.processes[finder]
+	existingProcessHasFounded := make(map[*ProcessContext]bool)
+	for _, p := range existingProcesses {
+		existingProcessHasFounded[p] = false
+	}
 
-			for update := range needToSyncProcesses {
-				// should only have one process if they have the same layer and detect type
-				if update.Entity().Layer != p.Entity().Layer {
-					continue
-				}
-				tmp := p
-				if !s.finders[finder].ValidateProcessIsSame(p.detectProcess, update) {
-					tmp = s.constructNewProcessContext(finder, update)
-				}
-				result = append(result, tmp)
-				needToSyncProcesses[update] = true
+	for _, syncProcess := range processes {
+		founded := false
+		for _, existingProcess := range existingProcesses {
+			if syncProcess.Pid() == existingProcess.Pid() && syncProcess.Entity().SameWith(existingProcess.Entity()) {
+				newProcesses = append(newProcesses, existingProcess)
+				existingProcessHasFounded[existingProcess] = true
+				founded = true
 				break
 			}
 		}
 
-		for p, hasSync := range needToSyncProcesses {
-			if !hasSync {
-				result = append(result, s.constructNewProcessContext(finder, p))
-			}
+		// if not found in existing processes, need to add this process
+		if !founded {
+			newProcesses = append(newProcesses, s.constructNewProcessContext(finder, syncProcess))
+			log.Infof("detected new process: pid: %d, entity: %s", syncProcess.Pid(), syncProcess.Entity())
 		}
-
-		s.processes[pid] = &processesWrapper{result}
 	}
 
-	// other processes are need to be added
-	for pid, ps := range pidToProcess {
-		result := make([]*ProcessContext, 0)
-		for p := range ps {
-			result = append(result, s.constructNewProcessContext(finder, p))
+	// log the dead processes
+	for p, found := range existingProcessHasFounded {
+		if found {
+			continue
 		}
-		s.processes[pid] = &processesWrapper{result}
+		log.Infof("the process has been recognized as dead, so deleted. pid: %d, entity: %s, id: %s", p.Pid(), p.Entity(), p.id)
 	}
+
+	s.processes[finder] = newProcesses
 }
 
 func (s *ProcessStorage) constructNewProcessContext(finder api.ProcessDetectType, process base.DetectedProcess) *ProcessContext {
@@ -270,18 +255,22 @@ func (s *ProcessStorage) constructNewProcessContext(finder api.ProcessDetectType
 }
 
 func (s *ProcessStorage) updateProcessToUploadSuccess(pc *ProcessContext, id string) {
+	reported := pc.id == id
 	pc.id = id
 	pc.syncStatus = ReportSuccess
-	log.Infof("uploaded process pid: %d, name: %s, id: %s", pc.detectProcess.Pid(), pc.detectProcess.Entity().ProcessName, id)
+	if !reported {
+		log.Infof("uploaded process pid: %d, name: %s, id: %s", pc.detectProcess.Pid(), pc.detectProcess.Entity().ProcessName, id)
+	}
 }
 
 func (s *ProcessStorage) updateProcessToUploadIgnored(pc *ProcessContext) {
 	pc.syncStatus = Ignore
+	log.Infof("could not found the process id from upstream, pid: %d, entity: %v", pc.Pid(), pc.Entity())
 }
 
 func (s *ProcessStorage) FindProcessByID(processID string) api.ProcessInterface {
-	for _, wrapper := range s.processes {
-		for _, p := range wrapper.processes {
+	for _, finderProcesses := range s.processes {
+		for _, p := range finderProcesses {
 			if p.id == processID {
 				return p
 			}
@@ -289,20 +278,3 @@ func (s *ProcessStorage) FindProcessByID(processID string) api.ProcessInterface
 	}
 	return nil
 }
-
-// processesWrapper used to wrap multiple process context which has the same pid
-// Usually they have difference entity
-type processesWrapper struct {
-	processes []*ProcessContext
-}
-
-func (w *processesWrapper) deleteWithSameFinder(finder api.ProcessDetectType) bool {
-	existingProcesses := make([]*ProcessContext, 0)
-	for _, p := range w.processes {
-		if p.DetectType() != finder {
-			existingProcesses = append(existingProcesses, p)
-		}
-	}
-	w.processes = existingProcesses
-	return len(w.processes) == 0
-}
diff --git a/pkg/process/module.go b/pkg/process/module.go
index f3f728e..38ec707 100644
--- a/pkg/process/module.go
+++ b/pkg/process/module.go
@@ -56,7 +56,8 @@ func (m *Module) Start(ctx context.Context, mgr *module.Manager) error {
 	if err != nil {
 		return err
 	}
-	processManager, err := finders.NewProcessManager(ctx, mgr, period, m.config.Scanner, m.config.Kubernetes)
+	processManager, err := finders.NewProcessManager(ctx, mgr, period, m.config.PropertiesReportPeriod,
+		m.config.Scanner, m.config.Kubernetes)
 	if err != nil {
 		return err
 	}