314 lines
8.9 KiB
Go
314 lines
8.9 KiB
Go
// Copyright 2014 Google Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package influxdb
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/cadvisor/info"
|
|
"github.com/google/cadvisor/storage"
|
|
"github.com/influxdb/influxdb-go"
|
|
"github.com/kr/pretty"
|
|
)
|
|
|
|
type influxdbStorage struct {
|
|
client *influxdb.Client
|
|
prevStats *info.ContainerStats
|
|
machineName string
|
|
tableName string
|
|
windowLen time.Duration
|
|
}
|
|
|
|
func (self *influxdbStorage) containerStatsToValues(
|
|
ref info.ContainerReference,
|
|
stats *info.ContainerStats,
|
|
) (columns []string, values []interface{}) {
|
|
|
|
// Machine name
|
|
columns = append(columns, "machine")
|
|
values = append(values, self.machineName)
|
|
|
|
// Container path
|
|
columns = append(columns, "container_path")
|
|
values = append(values, ref.Name)
|
|
|
|
// Cumulative Cpu Usage
|
|
columns = append(columns, "cpu_cumulative_usage")
|
|
values = append(values, stats.Cpu.Usage.Total)
|
|
|
|
// Cumulative Cpu Usage in kernel mode
|
|
columns = append(columns, "cpu_cumulative_usage_kernel")
|
|
values = append(values, stats.Cpu.Usage.System)
|
|
|
|
// Cumulative Cpu Usage in user mode
|
|
columns = append(columns, "cpu_cumulative_usage_user")
|
|
values = append(values, stats.Cpu.Usage.User)
|
|
|
|
// Memory Usage
|
|
columns = append(columns, "memory_usage")
|
|
values = append(values, stats.Memory.Usage)
|
|
|
|
// Working set size
|
|
columns = append(columns, "memory_working_set")
|
|
values = append(values, stats.Memory.WorkingSet)
|
|
|
|
// container page fault
|
|
columns = append(columns, "memory_container_pgfault")
|
|
values = append(values, stats.Memory.ContainerData.Pgfault)
|
|
|
|
// container major page fault
|
|
columns = append(columns, "memory_container_pgmajfault")
|
|
values = append(values, stats.Memory.ContainerData.Pgmajfault)
|
|
|
|
// hierarchical page fault
|
|
columns = append(columns, "memory_hierarchical_pgfault")
|
|
values = append(values, stats.Memory.HierarchicalData.Pgfault)
|
|
|
|
// hierarchical major page fault
|
|
columns = append(columns, "memory_hierarchical_pgmajfault")
|
|
values = append(values, stats.Memory.HierarchicalData.Pgmajfault)
|
|
|
|
// per cpu cumulative usage
|
|
for i, u := range stats.Cpu.Usage.PerCpu {
|
|
columns = append(columns, fmt.Sprintf("per_core_cumulative_usage_core_%v", i))
|
|
values = append(values, u)
|
|
}
|
|
|
|
sample, err := info.NewSample(self.prevStats, stats)
|
|
if err != nil || sample == nil {
|
|
return columns, values
|
|
}
|
|
|
|
// Optional: sample duration. Unit: Nanosecond.
|
|
columns = append(columns, "sample_duration")
|
|
values = append(values, sample.Duration.Nanoseconds())
|
|
|
|
// Optional: Instant cpu usage
|
|
columns = append(columns, "cpu_instant_usage")
|
|
values = append(values, sample.Cpu.Usage)
|
|
|
|
// Optional: Instant per core usage
|
|
for i, u := range sample.Cpu.PerCpuUsage {
|
|
columns = append(columns, fmt.Sprintf("per_core_instant_usage_core_%v", i))
|
|
values = append(values, u)
|
|
}
|
|
|
|
return columns, values
|
|
}
|
|
|
|
func (self *influxdbStorage) valuesToContainerStats(columns []string, values []interface{}) *info.ContainerStats {
|
|
stats := &info.ContainerStats{
|
|
Cpu: &info.CpuStats{},
|
|
Memory: &info.MemoryStats{},
|
|
}
|
|
perCoreUsage := make(map[int]uint64, 32)
|
|
for i, col := range columns {
|
|
v := values[i]
|
|
switch col {
|
|
case "machine":
|
|
if v.(string) != self.machineName {
|
|
return nil
|
|
}
|
|
// Cumulative Cpu Usage
|
|
case "cpu_cumulative_usage":
|
|
stats.Cpu.Usage.Total = v.(uint64)
|
|
// Cumulative Cpu Usage in kernel mode
|
|
case "cpu_cumulative_usage_kernel":
|
|
stats.Cpu.Usage.System = v.(uint64)
|
|
// Cumulative Cpu Usage in user mode
|
|
case "cpu_cumulative_usage_user":
|
|
stats.Cpu.Usage.User = v.(uint64)
|
|
// Memory Usage
|
|
case "memory_usage":
|
|
stats.Memory.Usage = v.(uint64)
|
|
// Working set size
|
|
case "memory_working_set":
|
|
stats.Memory.WorkingSet = v.(uint64)
|
|
// container page fault
|
|
case "memory_container_pgfault":
|
|
stats.Memory.ContainerData.Pgfault = v.(uint64)
|
|
// container major page fault
|
|
case "memory_container_pgmajfault":
|
|
stats.Memory.ContainerData.Pgmajfault = v.(uint64)
|
|
// hierarchical page fault
|
|
case "memory_hierarchical_pgfault":
|
|
stats.Memory.HierarchicalData.Pgfault = v.(uint64)
|
|
// hierarchical major page fault
|
|
case "memory_hierarchical_pgmajfault":
|
|
stats.Memory.HierarchicalData.Pgmajfault = v.(uint64)
|
|
default:
|
|
if !strings.HasPrefix(col, "per_core_cumulative_usage_core_") {
|
|
continue
|
|
}
|
|
idxStr := col[len("per_core_cumulative_usage_core_"):]
|
|
idx, err := strconv.Atoi(idxStr)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
perCoreUsage[idx] = v.(uint64)
|
|
}
|
|
}
|
|
stats.Cpu.Usage.PerCpu = make([]uint64, len(perCoreUsage))
|
|
for idx, usage := range perCoreUsage {
|
|
stats.Cpu.Usage.PerCpu[idx] = usage
|
|
}
|
|
return stats
|
|
}
|
|
|
|
func (self *influxdbStorage) valuesToContainerSample(columns []string, values []interface{}) *info.ContainerStatsSample {
|
|
sample := &info.ContainerStatsSample{}
|
|
perCoreUsage := make(map[int]uint64, 32)
|
|
for i, col := range columns {
|
|
v := values[i]
|
|
switch col {
|
|
case "machine":
|
|
if v.(string) != self.machineName {
|
|
return nil
|
|
}
|
|
// Memory Usage
|
|
case "memory_usage":
|
|
sample.Memory.Usage = v.(uint64)
|
|
// sample duration. Unit: Nanosecond.
|
|
case "sample_duration":
|
|
sample.Duration = time.Duration(v.(int64))
|
|
// Instant cpu usage
|
|
case "cpu_instant_usage":
|
|
sample.Cpu.Usage = v.(uint64)
|
|
|
|
default:
|
|
if !strings.HasPrefix(col, "per_core_instant_usage_core_") {
|
|
continue
|
|
}
|
|
idxStr := col[len("per_core_instant_usage_core_"):]
|
|
idx, err := strconv.Atoi(idxStr)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
perCoreUsage[idx] = v.(uint64)
|
|
}
|
|
}
|
|
sample.Cpu.PerCpuUsage = make([]uint64, len(perCoreUsage))
|
|
for idx, usage := range perCoreUsage {
|
|
sample.Cpu.PerCpuUsage[idx] = usage
|
|
}
|
|
if sample.Duration.Nanoseconds() == 0 {
|
|
return nil
|
|
}
|
|
return sample
|
|
}
|
|
|
|
func (self *influxdbStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error {
|
|
series := &influxdb.Series{
|
|
Name: self.tableName,
|
|
// There's only one point for each stats
|
|
Points: make([][]interface{}, 1),
|
|
}
|
|
series.Columns, series.Points[0] = self.containerStatsToValues(ref, stats)
|
|
|
|
self.prevStats = stats.Copy(self.prevStats)
|
|
pretty.Printf("% #v", series)
|
|
err := self.client.WriteSeries([]*influxdb.Series{series})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (self *influxdbStorage) RecentStats(containerName string, numStats int) ([]*info.ContainerStats, error) {
|
|
// TODO(dengnan): select only columns that we need
|
|
// TODO(dengnan): escape containerName
|
|
query := fmt.Sprintf("select * from %v limit %v where container_path=\"%v\"", self.tableName, numStats, containerName)
|
|
series, err := self.client.Query(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
statsList := make([]*info.ContainerStats, 0, len(series))
|
|
for _, s := range series {
|
|
for _, values := range s.Points {
|
|
stats := self.valuesToContainerStats(s.Columns, values)
|
|
statsList = append(statsList, stats)
|
|
}
|
|
}
|
|
return statsList, nil
|
|
}
|
|
|
|
func (self *influxdbStorage) Samples(containerName string, numSamples int) ([]*info.ContainerStatsSample, error) {
|
|
query := fmt.Sprintf("select * from %v limit %v where container_path=\"%v\"", self.tableName, numSamples, containerName)
|
|
series, err := self.client.Query(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sampleList := make([]*info.ContainerStatsSample, 0, len(series))
|
|
for _, s := range series {
|
|
for _, values := range s.Points {
|
|
sample := self.valuesToContainerSample(s.Columns, values)
|
|
sampleList = append(sampleList, sample)
|
|
}
|
|
}
|
|
return sampleList, nil
|
|
}
|
|
|
|
func (self *influxdbStorage) Close() error {
|
|
self.client = nil
|
|
return nil
|
|
}
|
|
|
|
func (self *influxdbStorage) Percentiles(
|
|
containerName string,
|
|
cpuUsagePercentiles []int,
|
|
memUsagePercentiles []int,
|
|
) (*info.ContainerStatsPercentiles, error) {
|
|
// TODO(dengnan): Implement it
|
|
return nil, nil
|
|
}
|
|
|
|
// machineName: A unique identifier to identify the host that current cAdvisor
|
|
// instance is running on.
|
|
// hostname: The host which runs influxdb.
|
|
// percentilesDuration: Time window which will be considered when calls Percentiles()
|
|
func New(machineName,
|
|
tablename,
|
|
database,
|
|
username,
|
|
password,
|
|
hostname string,
|
|
percentilesDuration time.Duration,
|
|
) (storage.StorageDriver, error) {
|
|
config := &influxdb.ClientConfig{
|
|
Host: hostname,
|
|
Username: username,
|
|
Password: password,
|
|
Database: database,
|
|
// IsSecure: true,
|
|
}
|
|
client, err := influxdb.NewClient(config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if percentilesDuration.Seconds() < 1.0 {
|
|
percentilesDuration = 5 * time.Minute
|
|
}
|
|
|
|
ret := &influxdbStorage{
|
|
client: client,
|
|
windowLen: percentilesDuration,
|
|
machineName: machineName,
|
|
}
|
|
return ret, nil
|
|
}
|