github.com/jcarley/cli@v0.0.0-20180201210820-966d90434c30/commands/metrics/csv.go (about)

     1  package metrics
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/csv"
     6  	"fmt"
     7  
     8  	"github.com/Sirupsen/logrus"
     9  	"github.com/daticahealth/cli/models"
    10  )
    11  
    12  // CSVTransformer is a concrete implementation of Transformer transforming data
    13  // into CSV format.
    14  type CSVTransformer struct {
    15  	HeadersWritten bool
    16  	GroupMode      bool
    17  	Buffer         *bytes.Buffer
    18  	Writer         *csv.Writer
    19  }
    20  
    21  // WriteHeadersCPU outputs the csv headers needed for cpu data. If GroupMode
    22  // is enabled, the service name is the first header.
    23  func (csv *CSVTransformer) WriteHeadersCPU() {
    24  	if !csv.HeadersWritten {
    25  		headers := []string{"timestamp", "cpu_percentage"}
    26  		if csv.GroupMode {
    27  			headers = append([]string{"service_name"}, headers...)
    28  		}
    29  		csv.Writer.Write(headers)
    30  		csv.HeadersWritten = true
    31  	}
    32  }
    33  
    34  // WriteHeadersMemory outputs the csv headers needed for memory data. If
    35  // GroupMode is enabled, the service name is the first header.
    36  func (csv *CSVTransformer) WriteHeadersMemory() {
    37  	if !csv.HeadersWritten {
    38  		headers := []string{"timestamp", "memory_min", "memory_max", "memory_avg", "memory_total"}
    39  		if csv.GroupMode {
    40  			headers = append([]string{"service_name"}, headers...)
    41  		}
    42  		csv.Writer.Write(headers)
    43  		csv.HeadersWritten = true
    44  	}
    45  }
    46  
    47  // WriteHeadersNetworkIn outputs the csv headers needed for received network
    48  // data. If GroupMode is enabled, the service name is the first header.
    49  func (csv *CSVTransformer) WriteHeadersNetworkIn() {
    50  	if !csv.HeadersWritten {
    51  		headers := []string{"timestamp", "rx_bytes", "rx_packets"}
    52  		if csv.GroupMode {
    53  			headers = append([]string{"service_name"}, headers...)
    54  		}
    55  		csv.Writer.Write(headers)
    56  		csv.HeadersWritten = true
    57  	}
    58  }
    59  
    60  // WriteHeadersNetworkOut outputs the csv headers needed for transmitted network
    61  // data. If GroupMode is enabled, the service name is the first header.
    62  func (csv *CSVTransformer) WriteHeadersNetworkOut() {
    63  	if !csv.HeadersWritten {
    64  		headers := []string{"timestamp", "tx_bytes", "tx_packets"}
    65  		if csv.GroupMode {
    66  			headers = append([]string{"service_name"}, headers...)
    67  		}
    68  		csv.Writer.Write(headers)
    69  		csv.HeadersWritten = true
    70  	}
    71  }
    72  
    73  // TransformGroupCPU transforms an entire environment's cpu data into csv
    74  // format. This outputs TransformSingleCPU for each service in the environment.
    75  func (csv *CSVTransformer) TransformGroupCPU(metrics *[]models.Metrics) {
    76  	csv.GroupMode = true
    77  	for _, metric := range *metrics {
    78  		if _, ok := blacklist[metric.ServiceLabel]; !ok {
    79  			csv.TransformSingleCPU(&metric)
    80  		}
    81  	}
    82  	csv.Writer.Flush()
    83  	logrus.Println(csv.Buffer.String())
    84  }
    85  
    86  // TransformGroupMemory transforms an entire environment's memory data into csv
    87  // format. This outputs TransformSingleMemory for each service in the
    88  // environment.
    89  func (csv *CSVTransformer) TransformGroupMemory(metrics *[]models.Metrics) {
    90  	csv.GroupMode = true
    91  	for _, metric := range *metrics {
    92  		if _, ok := blacklist[metric.ServiceLabel]; !ok {
    93  			csv.TransformSingleMemory(&metric)
    94  		}
    95  	}
    96  	csv.Writer.Flush()
    97  	logrus.Println(csv.Buffer.String())
    98  }
    99  
   100  // TransformGroupNetworkIn transforms an entire environment's received network
   101  // data into csv format. This outputs TransformSingleNetworkIn for each service
   102  // in the environment.
   103  func (csv *CSVTransformer) TransformGroupNetworkIn(metrics *[]models.Metrics) {
   104  	csv.GroupMode = true
   105  	for _, metric := range *metrics {
   106  		if _, ok := blacklist[metric.ServiceLabel]; !ok {
   107  			csv.TransformSingleNetworkIn(&metric)
   108  		}
   109  	}
   110  	csv.Writer.Flush()
   111  	logrus.Println(csv.Buffer.String())
   112  }
   113  
   114  // TransformGroupNetworkOut transforms an entire environment's transmitted
   115  // network data into csv format. This outputs TransformSingleNetworkOut for
   116  // each service in the environment.
   117  func (csv *CSVTransformer) TransformGroupNetworkOut(metrics *[]models.Metrics) {
   118  	csv.GroupMode = true
   119  	for _, metric := range *metrics {
   120  		if _, ok := blacklist[metric.ServiceLabel]; !ok {
   121  			csv.TransformSingleNetworkOut(&metric)
   122  		}
   123  	}
   124  	csv.Writer.Flush()
   125  	logrus.Println(csv.Buffer.String())
   126  }
   127  
   128  // TransformSingleCPU transforms a single service's CPU data into csv format.
   129  func (csv *CSVTransformer) TransformSingleCPU(metric *models.Metrics) {
   130  	csv.WriteHeadersCPU()
   131  	if metric.Data != nil && metric.Data.CPUUsage != nil {
   132  		for _, data := range *metric.Data.CPUUsage {
   133  			row := []string{
   134  				fmt.Sprintf("%d", data.TS),
   135  				fmt.Sprintf("%f", data.CorePercent*100.0),
   136  			}
   137  			if csv.GroupMode {
   138  				row = append([]string{metric.ServiceLabel}, row...)
   139  			}
   140  			csv.Writer.Write(row)
   141  		}
   142  	}
   143  	if !csv.GroupMode {
   144  		csv.Writer.Flush()
   145  		logrus.Println(csv.Buffer.String())
   146  	}
   147  }
   148  
   149  // TransformSingleMemory transforms a single service's memory data into csv
   150  // format.
   151  func (csv *CSVTransformer) TransformSingleMemory(metric *models.Metrics) {
   152  	csv.WriteHeadersMemory()
   153  	if metric.Data != nil && metric.Data.MemoryUsage != nil {
   154  		for _, data := range *metric.Data.MemoryUsage {
   155  			row := []string{
   156  				fmt.Sprintf("%d", data.TS),
   157  				fmt.Sprintf("%f", data.Min/1024.0),
   158  				fmt.Sprintf("%f", data.Max/1024.0),
   159  				fmt.Sprintf("%f", data.AVG/1024.0),
   160  				fmt.Sprintf("%f", float64(metric.Size.RAM*1024.0)),
   161  			}
   162  			if csv.GroupMode {
   163  				row = append([]string{metric.ServiceLabel}, row...)
   164  			}
   165  			csv.Writer.Write(row)
   166  		}
   167  	}
   168  	if !csv.GroupMode {
   169  		csv.Writer.Flush()
   170  		logrus.Println(csv.Buffer.String())
   171  	}
   172  }
   173  
   174  // TransformSingleNetworkIn transforms a single service's received network data
   175  // into csv format.
   176  func (csv *CSVTransformer) TransformSingleNetworkIn(metric *models.Metrics) {
   177  	csv.WriteHeadersNetworkIn()
   178  	if metric.Data != nil && metric.Data.NetworkUsage != nil {
   179  		for _, data := range *metric.Data.NetworkUsage {
   180  			row := []string{
   181  				fmt.Sprintf("%d", data.TS),
   182  				fmt.Sprintf("%f", data.RXKB),
   183  				fmt.Sprintf("%f", data.RXPackets),
   184  			}
   185  			if csv.GroupMode {
   186  				row = append([]string{metric.ServiceLabel}, row...)
   187  			}
   188  			csv.Writer.Write(row)
   189  		}
   190  	}
   191  	if !csv.GroupMode {
   192  		csv.Writer.Flush()
   193  		logrus.Println(csv.Buffer.String())
   194  	}
   195  }
   196  
   197  // TransformSingleNetworkOut transforms a single service's transmitted network
   198  // data into csv format.
   199  func (csv *CSVTransformer) TransformSingleNetworkOut(metric *models.Metrics) {
   200  	csv.WriteHeadersNetworkOut()
   201  	if metric.Data != nil && metric.Data.NetworkUsage != nil {
   202  		for _, data := range *metric.Data.NetworkUsage {
   203  			row := []string{
   204  				fmt.Sprintf("%d", data.TS),
   205  				fmt.Sprintf("%f", data.TXKB),
   206  				fmt.Sprintf("%f", data.TXPackets),
   207  			}
   208  			if csv.GroupMode {
   209  				row = append([]string{metric.ServiceLabel}, row...)
   210  			}
   211  			csv.Writer.Write(row)
   212  		}
   213  	}
   214  	if !csv.GroupMode {
   215  		csv.Writer.Flush()
   216  		logrus.Println(csv.Buffer.String())
   217  	}
   218  }