github.com/galamsiva2020/kubernetes-heapster-monitoring@v0.0.0-20210823134957-3c1baa7c1e70/metrics/sinks/kafka/driver.go (about)

     1  // Copyright 2015 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package kafka
    16  
    17  import (
    18  	"net/url"
    19  	"sync"
    20  	"time"
    21  
    22  	"github.com/golang/glog"
    23  	kafka_common "k8s.io/heapster/common/kafka"
    24  	"k8s.io/heapster/metrics/core"
    25  )
    26  
    27  type KafkaSinkPoint struct {
    28  	MetricsName      string
    29  	MetricsValue     interface{}
    30  	MetricsTimestamp time.Time
    31  	MetricsTags      map[string]string
    32  }
    33  
    34  type kafkaSink struct {
    35  	kafka_common.KafkaClient
    36  	sync.RWMutex
    37  }
    38  
    39  func (sink *kafkaSink) Name() string {
    40  	return "kafka"
    41  }
    42  
    43  func (sink *kafkaSink) ExportData(dataBatch *core.DataBatch) {
    44  	sink.Lock()
    45  	defer sink.Unlock()
    46  
    47  	for _, metricSet := range dataBatch.MetricSets {
    48  		for metricName, metricValue := range metricSet.MetricValues {
    49  			point := KafkaSinkPoint{
    50  				MetricsName: metricName,
    51  				MetricsTags: metricSet.Labels,
    52  				MetricsValue: map[string]interface{}{
    53  					"value": metricValue.GetValue(),
    54  				},
    55  				MetricsTimestamp: dataBatch.Timestamp.UTC(),
    56  			}
    57  			err := sink.ProduceKafkaMessage(point)
    58  			if err != nil {
    59  				glog.Errorf("Failed to produce metric message: %s", err)
    60  			}
    61  		}
    62  		for _, metric := range metricSet.LabeledMetrics {
    63  			labels := make(map[string]string)
    64  			for k, v := range metricSet.Labels {
    65  				labels[k] = v
    66  			}
    67  			for k, v := range metric.Labels {
    68  				labels[k] = v
    69  			}
    70  			point := KafkaSinkPoint{
    71  				MetricsName: metric.Name,
    72  				MetricsTags: labels,
    73  				MetricsValue: map[string]interface{}{
    74  					"value": metric.GetValue(),
    75  				},
    76  				MetricsTimestamp: dataBatch.Timestamp.UTC(),
    77  			}
    78  			err := sink.ProduceKafkaMessage(point)
    79  			if err != nil {
    80  				glog.Errorf("Failed to produce metric message: %s", err)
    81  			}
    82  		}
    83  	}
    84  }
    85  
    86  func NewKafkaSink(uri *url.URL) (core.DataSink, error) {
    87  	client, err := kafka_common.NewKafkaClient(uri, kafka_common.TimeSeriesTopic)
    88  	if err != nil {
    89  		return nil, err
    90  	}
    91  
    92  	return &kafkaSink{
    93  		KafkaClient: client,
    94  	}, nil
    95  }