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 }