Merge pull request #70 from linkernetworks/phstsai/VX-69

DEV VX69: List handler for all resource, and get handler for pod and service.

deploy/kubernetes/apps/monitoring/cadvisor/cadvisor.yaml

@@ -11,6 +11,8 @@ spec:
     metadata:
       labels:
         name: cadvisor
+      annotations:
+        prometheus.io/scrape: 'true'
     spec:
       containers:
       - name: cadvisor

src/config/config.go

@@ -8,14 +8,14 @@ import (
 	"github.com/linkernetworks/logger"
 	"github.com/linkernetworks/mongo"
 	"github.com/linkernetworks/redis"
-	"github.com/linkernetworks/vortex/src/prometheus"
+	"github.com/linkernetworks/vortex/src/prometheusprovider"
 )
 
 type Config struct {
-	Redis      *redis.RedisConfig           `json:"redis"`
-	Mongo      *mongo.MongoConfig           `json:"mongo"`
-	Prometheus *prometheus.PrometheusConfig `json:"prometheus"`
-	Logger     logger.LoggerConfig          `json:"logger"`
+	Redis      *redis.RedisConfig                   `json:"redis"`
+	Mongo      *mongo.MongoConfig                   `json:"mongo"`
+	Prometheus *prometheusprovider.PrometheusConfig `json:"prometheus"`
+	Logger     logger.LoggerConfig                  `json:"logger"`
 
 	// the version settings of the current application
 	Version string `json:"version"`

src/entity/metrics_container.go

@@ -0,0 +1,5 @@
+package entity
+
+type ContainerMetrics struct {
+	ContainerName string `json:"containerName"`
+}

src/entity/metrics_controller.go

@@ -0,0 +1,10 @@
+package entity
+
+type ControllerMetrics struct {
+	ControllerName string            `json:"controllerName"`
+	Type           string            `json:"type"`
+	Namespace      string            `json:"namespace"`
+	Status         string            `json:"status"`
+	CreateAt       int               `json:"createAt"`
+	Labels         map[string]string `json:"labels"`
+}

src/entity/node_metrics.go → src/entity/metrics_node.go

@@ -15,6 +15,10 @@ type NICMetrics struct {
 }
 
 type NodeResourceMetrics struct {
+	CPURequests                 float32 `json:"cpuRequests"`
+	CPULimits                   float32 `json:"cpuLimits"`
+	MemoryRequests              float32 `json:"memoryRequests"`
+	MemoryLimits                float32 `json:"memoryLimits"`
 	AllocatableCPU              float32 `json:"allocatableCPU"`
 	AllocatableMemory           float32 `json:"allocatableMemory"`
 	AllocatablePods             float32 `json:"allocatablePods"`
@@ -23,17 +27,6 @@ type NodeResourceMetrics struct {
 	CapacityMemory              float32 `json:"capacityMemory"`
 	CapacityPods                float32 `json:"capacityPods"`
 	CapacityEphemeralStorage    float32 `json:"capacityEphemeralStorage"`
-	CPURequests                 float32 `json:"cpuRequests"`
-	CPULimits                   float32 `json:"cpuLimits"`
-	MemoryRequests              float32 `json:"memoryRequests"`
-	MemoryLimits                float32 `json:"memoryLimits"`
-}
-
-type NodeResourceShortMetrics struct {
-	CPURequests    float32 `json:"cpuRequests"`
-	CPULimits      float32 `json:"cpuLimits"`
-	MemoryRequests float32 `json:"memoryRequests"`
-	MemoryLimits   float32 `json:"memoryLimits"`
 }
 
 type NodeDetailMetrics struct {
@@ -47,17 +40,6 @@ type NodeDetailMetrics struct {
 	Labels            map[string]string `json:"labels"`
 }
 
-type NodeInfoMetrics struct {
-	NodeName string                   `json:"nodeName"`
-	Labels   map[string]string        `json:"labels"`
-	Status   string                   `json:"status"`
-	Resource NodeResourceShortMetrics `json:"resource"`
-}
-
-type NodeListMetrics struct {
-	Node map[string]NodeInfoMetrics `json:"node"`
-}
-
 type NodeMetrics struct {
 	Detail   NodeDetailMetrics     `json:"detail"`
 	Resource NodeResourceMetrics   `json:"resource"`

src/entity/metrics_pod.go

@@ -0,0 +1,15 @@
+package entity
+
+type PodMetrics struct {
+	PodName      string            `json:"podName"`
+	Namespace    string            `json:"namespace"`
+	Node         string            `json:"node"`
+	Status       string            `json:"status"`
+	CreateAt     int               `json:"createAt"`
+	CreateByKind string            `json:"createByKind"`
+	CreateByName string            `json:"createByName"`
+	IP           string            `json:"ip"`
+	Labels       map[string]string `json:"labels"`
+	RestartCount int               `json:"restartCount"`
+	Containers   []string          `json:"containers"`
+}

src/entity/metrics_service.go

@@ -0,0 +1,10 @@
+package entity
+
+type ServiceMetrics struct {
+	ServiceName string            `json:"serviceName"`
+	Namespace   string            `json:"namespace"`
+	Type        string            `json:"type"`
+	CreateAt    int               `json:"createAt"`
+	ClusterIP   string            `json:"clusterIP"`
+	Labels      map[string]string `json:"labels"`
+}

src/server/handler_node_metrics.go → src/prometheuscontroller/expression.go

@@ -1,103 +1,133 @@
-package server
+package prometheuscontroller
 
 import (
 	"strings"
 
 	"github.com/linkernetworks/vortex/src/entity"
-	response "github.com/linkernetworks/vortex/src/net/http"
-	"github.com/linkernetworks/vortex/src/web"
+	"github.com/linkernetworks/vortex/src/serviceprovider"
+	"github.com/prometheus/common/model"
 )
 
-func listNodeMetricsHandler(ctx *web.Context) {
-	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+type Expression struct {
+	Metrics     []string          `json:"metrics"`
+	QueryLabels map[string]string `json:"queryLabels"`
+	SumBy       []string          `json:"sumBy"`
+	Value       *int              `json:"value"`
+}
+
+func ListResource(sp *serviceprovider.Container, resource model.LabelName, expression Expression) ([]string, error) {
+	results, err := getElements(sp, expression)
+	if err != nil {
+		return nil, err
+	}
 
-	nodeList := entity.NodeListMetrics{}
-	nodeList.Node = map[string]entity.NodeInfoMetrics{}
+	resourceList := []string{}
+	for _, result := range results {
+		resourceList = append(resourceList, string(result.Metric[resource]))
+	}
 
-	// kube_node_info, kube_node_labels
-	results, err := queryFromPrometheus(sp, `{__name__=~"kube_node_info|kube_node_labels"}`)
+	return resourceList, nil
+}
+
+func GetPod(sp *serviceprovider.Container, id string) (entity.PodMetrics, error) {
+	pod := entity.PodMetrics{}
+	pod.Labels = map[string]string{}
+
+	expression := Expression{}
+	expression.Metrics = []string{"kube_pod_info", "kube_pod_created", "kube_pod_labels", "kube_pod_owner", "kube_pod_status_phase", "kube_pod_container_info", "kube_pod_container_status_restarts_total"}
+	expression.QueryLabels = map[string]string{"pod": id}
+
+	results, err := getElements(sp, expression)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return pod, err
 	}
 
 	for _, result := range results {
 		switch result.Metric["__name__"] {
 
-		case "kube_node_info":
-			nodeInfo := entity.NodeInfoMetrics{}
-			nodeInfo.NodeName = string(result.Metric["node"])
-			nodeList.Node[string(result.Metric["node"])] = nodeInfo
+		case "kube_pod_info":
+			pod.PodName = id
+			pod.IP = string(result.Metric["pod_ip"])
+			pod.Node = string(result.Metric["node"])
+			pod.Namespace = string(result.Metric["namespace"])
+			pod.CreateByKind = string(result.Metric["created_by_kind"])
+			pod.CreateByName = string(result.Metric["created_by_name"])
 
-		case "kube_node_labels":
-			nodeInfo := nodeList.Node[string(result.Metric["node"])]
-			nodeInfo.Labels = map[string]string{}
+		case "kube_pod_created":
+			pod.CreateAt = int(result.Value)
+
+		case "kube_pod_labels":
 			for key, value := range result.Metric {
 				if strings.HasPrefix(string(key), "label_") {
-					nodeInfo.Labels[strings.TrimPrefix(string(key), "label_")] = string(value)
+					pod.Labels[strings.TrimPrefix(string(key), "label_")] = string(value)
 				}
 			}
-			nodeList.Node[string(result.Metric["node"])] = nodeInfo
+
+		case "kube_pod_status_phase":
+			if int(result.Value) == 1 {
+				pod.Status = string(result.Metric["phase"])
+			}
+
+		case "kube_pod_container_info":
+			pod.Containers = append(pod.Containers, string(result.Metric["container"]))
+
+		case "kube_pod_container_status_restarts_total":
+			pod.RestartCount = pod.RestartCount + int(result.Value)
 		}
 	}
 
-	// kube_node_status_condition
-	results, err = queryFromPrometheus(sp, `{__name__=~"kube_node_status_condition",status="true"}==1`)
-	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
-	}
+	return pod, nil
+}
 
-	for _, result := range results {
-		nodeInfo := nodeList.Node[string(result.Metric["node"])]
-		nodeInfo.Status = string(result.Metric["condition"])
-		nodeList.Node[string(result.Metric["node"])] = nodeInfo
-	}
+func GetService(sp *serviceprovider.Container, id string) (entity.ServiceMetrics, error) {
+	service := entity.ServiceMetrics{}
+	service.Labels = map[string]string{}
 
-	// kube_pod_container_resource_limits, kube_pod_container_resource_requests
-	results, err = queryFromPrometheus(sp, `sum by(__name__, resource,node) ({__name__=~"kube_pod_container_resource_limits|kube_pod_container_resource_requests"})`)
+	expression := Expression{}
+	expression.Metrics = []string{"kube_service_info", "kube_service_created", "kube_service_labels", "kube_service_spec_type"}
+	expression.QueryLabels = map[string]string{"service": id}
+
+	results, err := getElements(sp, expression)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return service, err
 	}
 
 	for _, result := range results {
-		nodeInfo := nodeList.Node[string(result.Metric["node"])]
 		switch result.Metric["__name__"] {
-		case "kube_pod_container_resource_requests":
-			switch result.Metric["resource"] {
-			case "cpu":
-				nodeInfo.Resource.CPURequests = float32(result.Value)
-			case "memory":
-				nodeInfo.Resource.MemoryRequests = float32(result.Value)
-			}
-		case "kube_pod_container_resource_limits":
-			switch result.Metric["resource"] {
-			case "cpu":
-				nodeInfo.Resource.CPULimits = float32(result.Value)
-			case "memory":
-				nodeInfo.Resource.MemoryLimits = float32(result.Value)
+
+		case "kube_service_info":
+			service.ServiceName = id
+			service.Namespace = string(result.Metric["namespace"])
+			service.ClusterIP = string(result.Metric["cluster_ip"])
+
+		case "kube_service_spec_type":
+			service.Type = string(result.Metric["type"])
+
+		case "kube_service_created":
+			service.CreateAt = int(result.Value)
+
+		case "kube_service_labels":
+			for key, value := range result.Metric {
+				if strings.HasPrefix(string(key), "label_") {
+					service.Labels[strings.TrimPrefix(string(key), "label_")] = string(value)
+				}
 			}
 		}
-		nodeList.Node[string(result.Metric["node"])] = nodeInfo
+
 	}
 
-	resp.WriteEntity(nodeList)
+	return service, nil
 }
 
-func getNodeMetricsHandler(ctx *web.Context) {
-	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
-
-	id := req.PathParameter("id")
+func GetNode(sp *serviceprovider.Container, id string) (entity.NodeMetrics, error) {
 	node := entity.NodeMetrics{}
 	node.Detail.Labels = map[string]string{}
 	node.NICs = map[string]entity.NICMetrics{}
 
 	// kube_node_info, kube_node_created, node_network_interface, kube_node_labels, kube_node_status_capacity, kube_node_status_allocatable
-	results, err := queryFromPrometheus(sp, `{__name__=~"kube_node_info|kube_node_created|node_network_interface|kube_node_labels|kube_node_status_capacity|kube_node_status_allocatable",node=~"`+id+`"}`)
+	results, err := query(sp, `{__name__=~"kube_node_info|kube_node_created|node_network_interface|kube_node_labels|kube_node_status_capacity|kube_node_status_allocatable",node=~"`+id+`"}`)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return node, err
 	}
 
 	for _, result := range results {
@@ -147,19 +177,17 @@ func getNodeMetricsHandler(ctx *web.Context) {
 	}
 
 	// kube_node_status_condition
-	results, err = queryFromPrometheus(sp, `	{__name__=~"kube_node_status_condition",node=~"`+id+`",status="true"}==1`)
+	results, err = query(sp, `{__name__=~"kube_node_status_condition",node=~"`+id+`",status="true"}==1`)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return node, err
 	}
 
 	node.Detail.Status = string(results[0].Metric["condition"])
 
 	// kube_pod_container_resource_limits, kube_pod_container_resource_requests
-	results, err = queryFromPrometheus(sp, `sum by(__name__, resource) ({__name__=~"kube_pod_container_resource_limits|kube_pod_container_resource_requests",node=~"`+id+`"})`)
+	results, err = query(sp, `sum by(__name__, resource) ({__name__=~"kube_pod_container_resource_limits|kube_pod_container_resource_requests",node=~"`+id+`"})`)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return node, err
 	}
 
 	for _, result := range results {
@@ -182,10 +210,9 @@ func getNodeMetricsHandler(ctx *web.Context) {
 	}
 
 	// node_network_interface, node_network_receive_bytes_total, node_network_transmit_bytes_total, node_network_receive_packets_total, node_network_transmit_packets_total
-	results, err = queryFromPrometheus(sp, `{__name__=~"node_network_interface|node_network_receive_bytes_total|node_network_transmit_bytes_total|node_network_receive_packets_total|node_network_transmit_packets_total",node=~"`+id+`"}`)
+	results, err = query(sp, `{__name__=~"node_network_interface|node_network_receive_bytes_total|node_network_transmit_bytes_total|node_network_receive_packets_total|node_network_transmit_packets_total",node=~"`+id+`"}`)
 	if err != nil {
-		response.BadRequest(req.Request, resp.ResponseWriter, err)
-		return
+		return node, err
 	}
 
 	for _, result := range results {
@@ -221,5 +248,5 @@ func getNodeMetricsHandler(ctx *web.Context) {
 		}
 	}
 
-	resp.WriteEntity(node)
+	return node, nil
 }