Beispiel #1
0
func NewDecoder() Decoder {
	// Get supported metrics.
	return &defaultDecoder{
		supportedStatMetrics: sinksV1Api.SupportedStatMetrics(),
		lastExported:         make(map[timeseriesKey]time.Time),
	}
}
Beispiel #2
0
func (a *Api) exportMetricsSchema(request *restful.Request, response *restful.Response) {
	result := TimeseriesSchema{}
	for _, label := range sinksApi.CommonLabels() {
		result.CommonLabels = append(result.CommonLabels, LabelDescriptor{
			Key:         label.Key,
			Description: label.Description,
		})
	}
	for _, label := range sinksApi.PodLabels() {
		result.PodLabels = append(result.PodLabels, LabelDescriptor{
			Key:         label.Key,
			Description: label.Description,
		})
	}

	for _, metric := range sinksApi.SupportedStatMetrics() {
		md := MetricDescriptor{
			Name:        metric.Name,
			Description: metric.Description,
			Type:        metric.Type.String(),
			ValueType:   metric.ValueType.String(),
			Units:       metric.Units.String(),
		}
		for _, label := range metric.Labels {
			md.Labels = append(md.Labels, LabelDescriptor{
				Key:         label.Key,
				Description: label.Description,
			})
		}
		result.Metrics = append(result.Metrics, md)
	}
	response.WriteEntity(result)
}
Beispiel #3
0
// NewExternalSinkManager returns an external sink manager that will manage pushing data to all
// the sinks in 'externalSinks', which is a map of sink name to ExternalSink object.
func NewExternalSinkManager(externalSinks []sink_api.ExternalSink) (ExternalSinkManager, error) {
	// Get supported metrics.
	supportedMetrics := sink_api.SupportedStatMetrics()
	for i := range supportedMetrics {
		supportedMetrics[i].Labels = sink_api.SupportedLabels()
	}

	// Create the metrics.
	descriptors := make([]sink_api.MetricDescriptor, 0, len(supportedMetrics))
	for _, supported := range supportedMetrics {
		descriptors = append(descriptors, supported.MetricDescriptor)
	}

	for _, externalSink := range externalSinks {
		err := externalSink.Register(descriptors)
		if err != nil {
			return nil, err
		}
	}
	decoder := sink_api_old.NewDecoder()
	return &externalSinkManager{
		externalSinks: externalSinks,
		decoder:       decoder,
	}, nil
}
Beispiel #4
0
func supportedMetricsDescriptors() []sink_api.MetricDescriptor {
	// Get supported metrics.
	supportedMetrics := sink_api.SupportedStatMetrics()
	for i := range supportedMetrics {
		supportedMetrics[i].Labels = sink_api.SupportedLabels()
	}

	// Create the metrics.
	descriptors := make([]sink_api.MetricDescriptor, 0, len(supportedMetrics))
	for _, supported := range supportedMetrics {
		descriptors = append(descriptors, supported.MetricDescriptor)
	}
	return descriptors
}
Beispiel #5
0
func (self *externalSinkManager) DebugInfo() string {
	desc := "External Sinks\n"

	// Add metrics being exported.
	desc += "\tExported metrics:\n"
	for _, supported := range sink_api.SupportedStatMetrics() {
		desc += fmt.Sprintf("\t\t%s: %s", supported.Name, supported.Description)
	}

	// Add labels being used.
	desc += "\n\tExported labels:\n"
	for _, label := range sink_api.SupportedLabels() {
		desc += fmt.Sprintf("\t\t%s: %s", label.Key, label.Description)
	}
	desc += "\n\tExternal Sinks:\n"
	for _, externalSink := range self.externalSinks {
		desc += fmt.Sprintf("\n\t\t%s", externalSink.DebugInfo())
	}

	return desc
}
Beispiel #6
0
func (self *externalSinkManager) DebugInfo() string {
	b := &bytes.Buffer{}
	fmt.Fprintln(b, "External Sinks")

	// Add metrics being exported.
	fmt.Fprintln(b, "\tExported metrics:")
	for _, supported := range sink_api.SupportedStatMetrics() {
		fmt.Fprintf(b, "\t\t%s: %s\n", supported.Name, supported.Description)
	}

	// Add labels being used.
	fmt.Fprintln(b, "\tExported labels:")
	for _, label := range sink_api.SupportedLabels() {
		fmt.Fprintf(b, "\t\t%s: %s\n", label.Key, label.Description)
	}
	fmt.Fprintln(b, "\tExternal Sinks:")
	self.sinkMutex.RLock()
	defer self.sinkMutex.RUnlock()
	for _, externalSink := range self.externalSinks {
		fmt.Fprintf(b, "\t\t%s\n", externalSink.DebugInfo())
	}

	return b.String()
}
Beispiel #7
0
func TestRealInput(t *testing.T) {
	containers := []source_api.Container{
		getContainer("container1"),
	}
	pods := []source_api.Pod{
		{
			PodMetadata: source_api.PodMetadata{
				Name:      "pod1",
				ID:        "123",
				Namespace: "test",
				Hostname:  "1.2.3.4",
				Status:    "Running",
			},
			Containers: containers,
		},
		{
			PodMetadata: source_api.PodMetadata{
				Name:      "pod2",
				ID:        "123",
				Namespace: "test",
				Hostname:  "1.2.3.5",
				Status:    "Running",
			},
			Containers: containers,
		},
	}
	input := source_api.AggregateData{
		Pods:       pods,
		Containers: containers,
		Machine:    containers,
	}
	timeseries, err := NewDecoder().Timeseries(input)
	assert.NoError(t, err)
	assert.NotEmpty(t, timeseries)

	expectedFsStats := getFsStats(input)

	metrics := make(map[string][]sink_api.Timeseries)
	for index := range timeseries {
		series, ok := metrics[timeseries[index].Point.Name]
		if !ok {
			series = make([]sink_api.Timeseries, 0)
		}
		series = append(series, timeseries[index])
		metrics[timeseries[index].Point.Name] = series
	}

	statMetrics := sink_api.SupportedStatMetrics()
	for index := range statMetrics {
		series, ok := metrics[statMetrics[index].MetricDescriptor.Name]
		require.True(t, ok)
		for innerIndex, entry := range series {
			assert.Equal(t, statMetrics[index].MetricDescriptor, *series[innerIndex].MetricDescriptor)
			spec := containers[0].Spec
			stats := containers[0].Stats[0]
			switch entry.Point.Name {
			case "uptime":
				_, ok := entry.Point.Value.(int64)
				require.True(t, ok)
			case "cpu/usage":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Cpu.Usage.Total, value)
			case "memory/usage":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Memory.Usage, value)
			case "memory/working_set":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Memory.WorkingSet, value)
			case "memory/page_faults":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Memory.ContainerData.Pgfault, value)
			case "memory/major_page_faults":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Memory.ContainerData.Pgmajfault, value)
			case "network/rx":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Network.RxBytes, value)
			case "network/rx_errors":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Network.RxErrors, value)
			case "network/tx":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Network.TxBytes, value)
			case "network/tx_errors":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, stats.Network.TxErrors, value)
			case "filesystem/usage":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				name, ok := entry.Point.Labels[sink_api.LabelResourceID.Key]
				require.True(t, ok)
				assert.Equal(t, expectedFsStats[name].usage, value)
			case "cpu/limit":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				expected := (spec.Cpu.Limit * 1000) / 1024
				assert.Equal(t, expected, value)
			case "memory/limit":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				assert.Equal(t, spec.Memory.Limit, value)
			case "filesystem/limit":
				value, ok := entry.Point.Value.(int64)
				require.True(t, ok)
				name, ok := entry.Point.Labels[sink_api.LabelResourceID.Key]
				require.True(t, ok)
				assert.Equal(t, expectedFsStats[name].limit, value)
			default:
				t.Errorf("unexpected metric type")
			}
		}
	}
}