10133676377

Committed 28 Jul 2024 05:59PM UTC coverage: 72.836% (+0.001%) from 72.835%

Build # 10133676377

Build Type

push

github

Committed by

web-flow

Commit Message

[8.15](backport #2356) Upgrade helm to v3.14.2 (#2357)

* Upgrade helm to v3.14.2 (#2356)

* Bump helm

* Disable PSP feature leave rules

* Bumping elastic-agent-autodiscover

* Lint fixes

* Linter empty space

* Commenting out CI tests and removing codeblocks from core code

* Comment out EKS PSP

* Remove imports from CI tests

* Update rules coverage

(cherry picked from commit 0029a1ad6)

# Conflicts:
#	go.mod
#	go.sum

* Conflicts resolve

* Fixing tidy

---------

Co-authored-by: Evgeniy Belyi <jeniawhite92@gmail.com>

Run Details

8036 of 11033 relevant lines covered (72.84%)

16.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

29.49

/internal/resources/fetching/fetchers/k8s/kube_provider.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package fetchers

import (
        "reflect"

        "github.com/elastic/elastic-agent-autodiscover/kubernetes"
        "github.com/elastic/elastic-agent-libs/logp"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

        "github.com/elastic/cloudbeat/internal/resources/fetching"
        "github.com/elastic/cloudbeat/internal/resources/fetching/cycle"
)

type K8sResource struct {
        log  *logp.Logger
        Data any
}

const (
        k8sObjMetadataField  = "ObjectMeta"
        k8sTypeMetadataField = "TypeMeta"
        K8sObjType           = "k8s_object"

        ecsResourceTypeField = "orchestrator.resource.type"
        ecsResourceIdField   = "orchestrator.resource.id"
        ecsResourceNameField = "orchestrator.resource.name"
)

func getKubeData(log *logp.Logger, watchers []kubernetes.Watcher, resCh chan fetching.ResourceInfo, cycleMetadata cycle.Metadata) {
        log.Debug("Starting getKubeData")

        for _, watcher := range watchers {
                rs := watcher.Store().List()

                for _, r := range rs {
                        nullifyManagedFields(r)
                        resource, ok := r.(kubernetes.Resource)

                        if !ok {
                                log.Errorf("Bad resource: %#v does not implement kubernetes.Resource", r)
                                continue
                        }

                        err := addTypeInformationToKubeResource(resource)
                        if err != nil {
                                log.Errorf("Bad resource: %v", err)
                                continue
                        } // See https://github.com/kubernetes/kubernetes/issues/3030
                        resCh <- fetching.ResourceInfo{Resource: K8sResource{log, resource}, CycleMetadata: cycleMetadata}
                }
        }
}

func (r K8sResource) GetData() any {
        return r.Data
}

func (r K8sResource) GetMetadata() (fetching.ResourceMetadata, error) {
        k8sObj := reflect.Indirect(reflect.ValueOf(r.Data))
        k8sObjMeta := getK8sObjectMeta(r.log, k8sObj)
        resourceID := k8sObjMeta.UID
        resourceName := k8sObjMeta.Name

        return fetching.ResourceMetadata{
                ID:      string(resourceID),
                Type:    K8sObjType,
                SubType: getK8sSubType(r.log, k8sObj),
                Name:    resourceName,
        }, nil
}

func (r K8sResource) GetElasticCommonData() (map[string]any, error) {
        metadata, err := r.GetMetadata()
        if err != nil {
                return nil, err
        }

        fields := map[string]any{
                ecsResourceTypeField: metadata.SubType,
                ecsResourceNameField: metadata.Name,
                ecsResourceIdField:   metadata.ID,
        }

        return fields, nil
}

func getK8sObjectMeta(log *logp.Logger, k8sObj reflect.Value) metav1.ObjectMeta {
        metadata, ok := k8sObj.FieldByName(k8sObjMetadataField).Interface().(metav1.ObjectMeta)
        if !ok {
                log.Errorf("Failed to retrieve object metadata, Resource: %#v", k8sObj)
                return metav1.ObjectMeta{}
        }

        return metadata
}

func getK8sSubType(log *logp.Logger, k8sObj reflect.Value) string {
        typeMeta, ok := k8sObj.FieldByName(k8sTypeMetadataField).Interface().(metav1.TypeMeta)
        if !ok {
                log.Errorf("Failed to retrieve type metadata, Resource: %#v", k8sObj)
                return ""
        }

        return typeMeta.Kind
}

// nullifyManagedFields ManagedFields field contains fields with dot that prevent from elasticsearch to index
// the events.
func nullifyManagedFields(resource any) {
        switch val := resource.(type) {
        case *kubernetes.Pod:
                val.ManagedFields = nil
        case *kubernetes.Role:
                val.ManagedFields = nil
        case *kubernetes.RoleBinding:
                val.ManagedFields = nil
        case *kubernetes.ClusterRole:
                val.ManagedFields = nil
        case *kubernetes.ClusterRoleBinding:
                val.ManagedFields = nil
        case *kubernetes.ServiceAccount:
                val.ManagedFields = nil
        case *kubernetes.NetworkPolicy:
                val.ManagedFields = nil
        case *kubernetes.Node:
                val.ManagedFields = nil
        }
}

1	// Licensed to Elasticsearch B.V. under one or more contributor
2	// license agreements. See the NOTICE file distributed with
3	// this work for additional information regarding copyright
4	// ownership. Elasticsearch B.V. licenses this file to you under
5	// the Apache License, Version 2.0 (the "License"); you may
6	// not use this file except in compliance with the License.
7	// You may obtain a copy of the License at
8	//
9	// http://www.apache.org/licenses/LICENSE-2.0
10	//
11	// Unless required by applicable law or agreed to in writing,
12	// software distributed under the License is distributed on an
13	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14	// KIND, either express or implied. See the License for the
15	// specific language governing permissions and limitations
16	// under the License.
17
18	package fetchers
19
20	import (
21	"reflect"
22
23	"github.com/elastic/elastic-agent-autodiscover/kubernetes"
24	"github.com/elastic/elastic-agent-libs/logp"
25	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
26
27	"github.com/elastic/cloudbeat/internal/resources/fetching"
28	"github.com/elastic/cloudbeat/internal/resources/fetching/cycle"
29	)
30
31	type K8sResource struct {
32	log *logp.Logger
33	Data any
34	}
35
36	const (
37	k8sObjMetadataField = "ObjectMeta"
38	k8sTypeMetadataField = "TypeMeta"
39	K8sObjType = "k8s_object"
40
41	ecsResourceTypeField = "orchestrator.resource.type"
42	ecsResourceIdField = "orchestrator.resource.id"
43	ecsResourceNameField = "orchestrator.resource.name"
44	)
45
46	func getKubeData(log *logp.Logger, watchers []kubernetes.Watcher, resCh chan fetching.ResourceInfo, cycleMetadata cycle.Metadata) {	4✔
47	log.Debug("Starting getKubeData")	4✔
48		4✔
49	for _, watcher := range watchers {	32✔
50	rs := watcher.Store().List()	28✔
51		28✔
52	for _, r := range rs {	34✔
53	nullifyManagedFields(r)	6✔
54	resource, ok := r.(kubernetes.Resource)	6✔
55		6✔
56	if !ok {	6✔
57	log.Errorf("Bad resource: %#v does not implement kubernetes.Resource", r)	×
58	continue	×
59	}
60
61	err := addTypeInformationToKubeResource(resource)	6✔
62	if err != nil {	6✔
63	log.Errorf("Bad resource: %v", err)	×
64	continue	×
65	} // See https://github.com/kubernetes/kubernetes/issues/3030
66	resCh <- fetching.ResourceInfo{Resource: K8sResource{log, resource}, CycleMetadata: cycleMetadata}	6✔
67	}
68	}
69	}
70
71	func (r K8sResource) GetData() any {	6✔
72	return r.Data	6✔
73	}	6✔
74
75	func (r K8sResource) GetMetadata() (fetching.ResourceMetadata, error) {	×
76	k8sObj := reflect.Indirect(reflect.ValueOf(r.Data))	×
77	k8sObjMeta := getK8sObjectMeta(r.log, k8sObj)	×
78	resourceID := k8sObjMeta.UID	×
79	resourceName := k8sObjMeta.Name	×
80		×
81	return fetching.ResourceMetadata{	×
82	ID: string(resourceID),	×
83	Type: K8sObjType,	×
84	SubType: getK8sSubType(r.log, k8sObj),	×
85	Name: resourceName,	×
86	}, nil	×
87	}	×
88
89	func (r K8sResource) GetElasticCommonData() (map[string]any, error) {	×
90	metadata, err := r.GetMetadata()	×
91	if err != nil {	×
92	return nil, err	×
93	}	×
94
95	fields := map[string]any{	×
96	ecsResourceTypeField: metadata.SubType,	×
97	ecsResourceNameField: metadata.Name,	×
98	ecsResourceIdField: metadata.ID,	×
99	}	×
100		×
101	return fields, nil	×
102	}
103
104	func getK8sObjectMeta(log *logp.Logger, k8sObj reflect.Value) metav1.ObjectMeta {	×
105	metadata, ok := k8sObj.FieldByName(k8sObjMetadataField).Interface().(metav1.ObjectMeta)	×
106	if !ok {	×
107	log.Errorf("Failed to retrieve object metadata, Resource: %#v", k8sObj)	×
108	return metav1.ObjectMeta{}	×
109	}	×
110
111	return metadata	×
112	}
113
114	func getK8sSubType(log *logp.Logger, k8sObj reflect.Value) string {	×
115	typeMeta, ok := k8sObj.FieldByName(k8sTypeMetadataField).Interface().(metav1.TypeMeta)	×
116	if !ok {	×
117	log.Errorf("Failed to retrieve type metadata, Resource: %#v", k8sObj)	×
118	return ""	×
119	}	×
120
121	return typeMeta.Kind	×
122	}
123
124	// nullifyManagedFields ManagedFields field contains fields with dot that prevent from elasticsearch to index
125	// the events.
126	func nullifyManagedFields(resource any) {	6✔
127	switch val := resource.(type) {	6✔
128	case *kubernetes.Pod:	3✔
129	val.ManagedFields = nil	3✔
130	case *kubernetes.Role:	3✔
131	val.ManagedFields = nil	3✔
132	case *kubernetes.RoleBinding:	×
133	val.ManagedFields = nil	×
134	case *kubernetes.ClusterRole:	×
135	val.ManagedFields = nil	×
136	case *kubernetes.ClusterRoleBinding:	×
137	val.ManagedFields = nil	×
138	case *kubernetes.ServiceAccount:	×
139	val.ManagedFields = nil	×
140	case *kubernetes.NetworkPolicy:	×
141	val.ManagedFields = nil	×
142	case *kubernetes.Node:	×
143	val.ManagedFields = nil	×
144	}
145	}

elastic / cloudbeat / 10133676377

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous