Merge pull request #53 from snetsystems/release-1.23-snet-yongsik

Release 1.23 snet yongsik

Author: snetsystems

plugins/inputs/all/all.go

@@ -146,7 +146,8 @@ import (
 	_ "github.com/influxdata/telegraf/plugins/inputs/openstack"
 	_ "github.com/influxdata/telegraf/plugins/inputs/opentelemetry"
 	_ "github.com/influxdata/telegraf/plugins/inputs/openweathermap"
-	_ "github.com/influxdata/telegraf/plugins/inputs/oracledb"
+
+	// _ "github.com/influxdata/telegraf/plugins/inputs/oracledb"
 	_ "github.com/influxdata/telegraf/plugins/inputs/passenger"
 	_ "github.com/influxdata/telegraf/plugins/inputs/pf"
 	_ "github.com/influxdata/telegraf/plugins/inputs/pgbouncer"

plugins/inputs/kube_inventory/README.md

@@ -13,6 +13,7 @@ resources:
 - pods (containers)
 - services
 - statefulsets
+- resourcequotas
 
 Kubernetes is a fast moving project, with a new minor release every 3 months. As
 such, we will aim to maintain support only for versions that are supported by
@@ -61,7 +62,7 @@ avoid cardinality issues:
   ## Optional Resources to exclude from gathering
   ## Leave them with blank with try to gather everything available.
   ## Values can be - "daemonsets", deployments", "endpoints", "ingress", "nodes",
-  ## "persistentvolumes", "persistentvolumeclaims", "pods", "services", "statefulsets"
+  ## "persistentvolumes", "persistentvolumeclaims", "pods", "services", "statefulsets", "resourcequotas"
   # resource_exclude = [ "deployments", "nodes", "statefulsets" ]
 
   ## Optional Resources to include when gathering
@@ -97,7 +98,6 @@ list "persistentvolumes" and "nodes". You will then need to make an [aggregated
 ClusterRole][agg] that will eventually be bound to a user or group.
 
 [rbac]: https://kubernetes.io/docs/reference/access-authn-authz/rbac/
-
 [agg]: https://kubernetes.io/docs/reference/access-authn-authz/rbac/#aggregated-clusterroles
 
 ```yaml
@@ -107,11 +107,11 @@ apiVersion: rbac.authorization.k8s.io/v1
 metadata:
   name: influx:cluster:viewer
   labels:
-    rbac.authorization.k8s.io/aggregate-view-telegraf: "true"
+    rbac.authorization.k8s.io/aggregate-view-telegraf: 'true'
 rules:
-  - apiGroups: [""]
-    resources: ["persistentvolumes", "nodes"]
-    verbs: ["get", "list"]
+  - apiGroups: ['']
+    resources: ['persistentvolumes', 'nodes']
+    verbs: ['get', 'list']
 
 ---
 kind: ClusterRole
@@ -121,9 +121,9 @@ metadata:
 aggregationRule:
   clusterRoleSelectors:
     - matchLabels:
-        rbac.authorization.k8s.io/aggregate-view-telegraf: "true"
+        rbac.authorization.k8s.io/aggregate-view-telegraf: 'true'
     - matchLabels:
-        rbac.authorization.k8s.io/aggregate-to-view: "true"
+        rbac.authorization.k8s.io/aggregate-to-view: 'true'
 rules: [] # Rules are automatically filled in by the controller manager.
 ```
 
@@ -149,7 +149,7 @@ subjects:
 ## Quickstart in k3s
 
 When monitoring [k3s](https://k3s.io) server instances one can re-use already
-generated administration token.  This is less secure than using the more
+generated administration token. This is less secure than using the more
 restrictive dedicated telegraf user but more convienient to set up.
 
 ```console
@@ -170,6 +170,7 @@ tls_key = "/run/telegraf-kubernetes-key"
 ## Metrics
 
 - kubernetes_daemonset
+
   - tags:
     - daemonset_name
     - namespace
@@ -185,6 +186,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - updated_number_scheduled
 
 - kubernetes_deployment
+
   - tags:
     - deployment_name
     - namespace
@@ -195,6 +197,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - created
 
 - kubernetes_endpoints
+
   - tags:
     - endpoint_name
     - namespace
@@ -210,6 +213,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - port
 
 - kubernetes_ingress
+
   - tags:
     - ingress_name
     - namespace
@@ -225,6 +229,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - tls
 
 - kubernetes_node
+
   - tags:
     - node_name
   - fields:
@@ -238,6 +243,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - allocatable_pods
 
 - kubernetes_persistentvolume
+
   - tags:
     - pv_name
     - phase
@@ -246,6 +252,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - phase_type (int, [see below](#pv-phase_type))
 
 - kubernetes_persistentvolumeclaim
+
   - tags:
     - pvc_name
     - namespace
@@ -256,6 +263,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - phase_type (int, [see below](#pvc-phase_type))
 
 - kubernetes_pod_container
+
   - tags:
     - container_name
     - namespace
@@ -277,6 +285,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - resource_limits_memory_bytes
 
 - kubernetes_service
+
   - tags:
     - service_name
     - namespace
@@ -292,6 +301,7 @@ tls_key = "/run/telegraf-kubernetes-key"
     - target_port
 
 - kubernetes_statefulset
+
   - tags:
     - statefulset_name
     - namespace
@@ -306,6 +316,22 @@ tls_key = "/run/telegraf-kubernetes-key"
     - spec_replicas
     - observed_generation
 
+- kubernetes_statefulset
+  - tags:
+    - resource
+    - namespace
+  - fields:
+    - hard_cpu_cores_limit
+    - hard_cpu_cores_request
+    - hard_memory_bytes_limit
+    - hard_memory_bytes_request
+    - hard_storage_bytes_request
+    - used_cpu_cores_limit
+    - used_cpu_cores_request
+    - used_memory_bytes_limit
+    - used_memory_bytes_request
+    - used_storage_bytes_request
+
 ### pv `phase_type`
 
 The persistentvolume "phase" is saved in the `phase` tag with a correlated
@@ -345,6 +371,7 @@ kubernetes_pod,namespace=default,node_name=ip-172-17-0-2.internal,pod_name=tick1
 kubernetes_service,cluster_ip=172.29.61.80,namespace=redis-cache-0001,port_name=redis,port_protocol=TCP,selector_app=myapp,selector_io.kompose.service=redis,selector_role=slave,service_name=redis-slave created=1588690034000000000i,generation=0i,port=6379i,target_port=0i 1547597616000000000
 kubernetes_pod_container,container_name=telegraf,namespace=default,node_name=ip-172-17-0-2.internal,node_selector_node-role.kubernetes.io/compute=true,pod_name=tick1,phase=Running,state=running,readiness=ready resource_requests_cpu_units=0.1,resource_limits_memory_bytes=524288000,resource_limits_cpu_units=0.5,restarts_total=0i,state_code=0i,state_reason="",phase_reason="",resource_requests_memory_bytes=524288000 1547597616000000000
 kubernetes_statefulset,namespace=default,selector_select1=s1,statefulset_name=etcd replicas_updated=3i,spec_replicas=3i,observed_generation=1i,created=1544101669000000000i,generation=1i,replicas=3i,replicas_current=3i,replicas_ready=3i 1547597616000000000
+kubernetes_resourcequota,host=S2100113,namespace=test-prj0,resource=default-resource-quota hard_cpu_cores_limit=16i,hard_cpu_cores_request=16i,hard_memory_bytes_limit=34359738368i,hard_memory_bytes_request=34359738368i,hard_storage_bytes_request=107374182400i,used_cpu_cores_limit=1i,used_cpu_cores_request=1i,used_memory_bytes_limit=2684354560i,used_memory_bytes_request=2684354560i,used_storage_bytes_request=3221225472i 1683003895000000000
 ```
 
 [metric filtering]: https://github.com/influxdata/telegraf/blob/master/docs/CONFIGURATION.md#metric-filtering

plugins/inputs/kube_inventory/client.go

@@ -110,3 +110,9 @@ func (c *client) getStatefulSets(ctx context.Context) (*appsv1.StatefulSetList,
 	defer cancel()
 	return c.AppsV1().StatefulSets(c.namespace).List(ctx, metav1.ListOptions{})
 }
+
+func (c *client) getResourceQuotas(ctx context.Context) (*corev1.ResourceQuotaList, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+	return c.CoreV1().ResourceQuotas(c.namespace).List(ctx, metav1.ListOptions{})
+}

plugins/inputs/kube_inventory/kube_inventory.go

@@ -113,6 +113,7 @@ var availableCollectors = map[string]func(ctx context.Context, acc telegraf.Accu
 	"statefulsets":           collectStatefulSets,
 	"persistentvolumes":      collectPersistentVolumes,
 	"persistentvolumeclaims": collectPersistentVolumeClaims,
+	"resourcequotas":         collectResourceQuotas,
 }
 
 func atoi(s string) int64 {
@@ -160,6 +161,7 @@ var (
 	podContainerMeasurement          = "kubernetes_pod_container"
 	serviceMeasurement               = "kubernetes_service"
 	statefulSetMeasurement           = "kubernetes_statefulset"
+	resourcequotaMeasurement         = "kubernetes_resourcequota"
 )
 
 func init() {

plugins/inputs/kube_inventory/resourcequotas.go

@@ -0,0 +1,60 @@
+package kube_inventory
+
+import (
+	"context"
+
+	corev1 "k8s.io/api/core/v1"
+
+	"github.com/influxdata/telegraf"
+)
+
+func collectResourceQuotas(ctx context.Context, acc telegraf.Accumulator, ki *KubernetesInventory) {
+	list, err := ki.client.getResourceQuotas(ctx)
+	if err != nil {
+		acc.AddError(err)
+		return
+	}
+	for _, i := range list.Items {
+		ki.gatherResourceQuota(i, acc)
+	}
+}
+
+func (ki *KubernetesInventory) gatherResourceQuota(r corev1.ResourceQuota, acc telegraf.Accumulator) {
+	fields := map[string]interface{}{}
+	tags := map[string]string{
+		"resource":  r.Name,
+		"namespace": r.Namespace,
+	}
+
+	for resourceName, val := range r.Status.Hard {
+		switch resourceName {
+		case "limits.cpu":
+			fields["hard_cpu_cores_limit"] = ki.convertQuantity(val.String(), 1)
+		case "limits.memory":
+			fields["hard_memory_bytes_limit"] = ki.convertQuantity(val.String(), 1)
+		case "requests.cpu":
+			fields["hard_cpu_cores_request"] = ki.convertQuantity(val.String(), 1)
+		case "requests.memory":
+			fields["hard_memory_bytes_request"] = ki.convertQuantity(val.String(), 1)
+		case "requests.storage":
+			fields["hard_storage_bytes_request"] = ki.convertQuantity(val.String(), 1)
+		}
+	}
+
+	for resourceName, val := range r.Status.Used {
+		switch resourceName {
+		case "limits.cpu":
+			fields["used_cpu_cores_limit"] = ki.convertQuantity(val.String(), 1)
+		case "limits.memory":
+			fields["used_memory_bytes_limit"] = ki.convertQuantity(val.String(), 1)
+		case "requests.cpu":
+			fields["used_cpu_cores_request"] = ki.convertQuantity(val.String(), 1)
+		case "requests.memory":
+			fields["used_memory_bytes_request"] = ki.convertQuantity(val.String(), 1)
+		case "requests.storage":
+			fields["used_storage_bytes_request"] = ki.convertQuantity(val.String(), 1)
+		}
+	}
+
+	acc.AddFields(resourcequotaMeasurement, fields, tags)
+}

plugins/inputs/kube_inventory/resourcequotas_test.go

@@ -0,0 +1,121 @@
+package kube_inventory
+
+import (
+	"testing"
+	"time"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/testutil"
+	"github.com/stretchr/testify/require"
+)
+
+func TestResourceQuota(t *testing.T) {
+	cli := &client{}
+	now := time.Now()
+
+	tests := []struct {
+		name     string
+		handler  *mockHandler
+		output   []telegraf.Metric
+		hasError bool
+	}{
+		{
+			name: "no ressourcequota",
+			handler: &mockHandler{
+				responseMap: map[string]interface{}{
+					"/resourcequotas/": corev1.ResourceQuotaList{},
+				},
+			},
+			output:   []telegraf.Metric{},
+			hasError: false,
+		},
+		{
+			name: "collect resourceqota",
+			handler: &mockHandler{
+				responseMap: map[string]interface{}{
+					"/resourcequotas/": corev1.ResourceQuotaList{
+						Items: []corev1.ResourceQuota{
+							{
+								Status: corev1.ResourceQuotaStatus{
+									Hard: corev1.ResourceList{
+										"limits.cpu":       resource.MustParse("16"),
+										"limits.memory":    resource.MustParse("34359738368"),
+										"requests.cpu":     resource.MustParse("16"),
+										"requests.memory":  resource.MustParse("34359738368"),
+										"requests.storage": resource.MustParse("107374182400"),
+									},
+									Used: corev1.ResourceList{
+										"limits.cpu":       resource.MustParse("1"),
+										"limits.memory":    resource.MustParse("1610612736"),
+										"requests.cpu":     resource.MustParse("1"),
+										"requests.memory":  resource.MustParse("1610612736"),
+										"requests.storage": resource.MustParse("1073741824"),
+									},
+								},
+								ObjectMeta: metav1.ObjectMeta{
+									Generation: 11232,
+									Namespace:  "ns1",
+									Name:       "rs1",
+									Labels: map[string]string{
+										"lab1": "v1",
+										"lab2": "v2",
+									},
+									CreationTimestamp: metav1.Time{Time: now},
+								},
+							},
+						},
+					},
+				},
+			},
+			output: []telegraf.Metric{
+				testutil.MustMetric(
+					resourcequotaMeasurement,
+					map[string]string{
+						"resource":  "rs1",
+						"namespace": "ns1",
+					},
+					map[string]interface{}{
+						"hard_cpu_cores_limit":       int64(16),
+						"hard_memory_bytes_limit":    int64(34359738368),
+						"hard_cpu_cores_request":     int64(16),
+						"hard_memory_bytes_request":  int64(34359738368),
+						"hard_storage_bytes_request": int64(107374182400),
+						"used_cpu_cores_limit":       int64(1),
+						"used_memory_bytes_limit":    int64(1610612736),
+						"used_cpu_cores_request":     int64(1),
+						"used_memory_bytes_request":  int64(1610612736),
+						"used_storage_bytes_request": int64(1073741824),
+					},
+					time.Unix(0, 0),
+				),
+			},
+			hasError: false,
+		},
+	}
+
+	for _, v := range tests {
+		ks := &KubernetesInventory{
+			client: cli,
+		}
+		acc := new(testutil.Accumulator)
+		for _, quota := range ((v.handler.responseMap["/resourcequotas/"]).(corev1.ResourceQuotaList)).Items {
+			ks.gatherResourceQuota(quota, acc)
+		}
+
+		err := acc.FirstError()
+		if v.hasError {
+			require.Errorf(t, err, "%s failed, should have error", v.name)
+			continue
+		}
+
+		// No error case
+		require.NoErrorf(t, err, "%s failed, err: %v", v.name, err)
+
+		require.Len(t, acc.Metrics, len(v.output))
+		testutil.RequireMetricsEqual(t, acc.GetTelegrafMetrics(), v.output, testutil.IgnoreTime())
+	}
+}