Merge ddc4057 into 2325502

cmd/agent/app/builder.go

@@ -117,7 +117,7 @@ func (b *Builder) getMetricsFactory() (metrics.Factory, error) {
 	if b.metricsFactory != nil {
 		return b.metricsFactory, nil
 	}
-	return b.Metrics.CreateMetricsFactory("jaeger_agent")
+	return b.Metrics.CreateMetricsFactory("jaeger-agent")
 }
 
 // CreateAgent creates the Agent

cmd/collector/app/metrics.go

@@ -71,12 +71,12 @@ type CountsBySpanType struct {
 // NewSpanProcessorMetrics returns a SpanProcessorMetrics
 func NewSpanProcessorMetrics(serviceMetrics metrics.Factory, hostMetrics metrics.Factory, otherFormatTypes []string) *SpanProcessorMetrics {
 	spanCounts := map[string]CountsBySpanType{
-		ZipkinFormatType:  newCountsBySpanType(serviceMetrics.Namespace(ZipkinFormatType, nil)),
-		JaegerFormatType:  newCountsBySpanType(serviceMetrics.Namespace(JaegerFormatType, nil)),
-		UnknownFormatType: newCountsBySpanType(serviceMetrics.Namespace(UnknownFormatType, nil)),
+		ZipkinFormatType:  newCountsBySpanType(serviceMetrics.Namespace("", map[string]string{"format": "zipkin"})),
+		JaegerFormatType:  newCountsBySpanType(serviceMetrics.Namespace("", map[string]string{"format": "jaeger"})),
+		UnknownFormatType: newCountsBySpanType(serviceMetrics.Namespace("", map[string]string{"format": "unknown"})),
 	}
 	for _, otherFormatType := range otherFormatTypes {
-		spanCounts[otherFormatType] = newCountsBySpanType(serviceMetrics.Namespace(otherFormatType, nil))
+		spanCounts[otherFormatType] = newCountsBySpanType(serviceMetrics.Namespace("", map[string]string{"format": otherFormatType}))
 	}
 	m := &SpanProcessorMetrics{
 		SaveLatency:    hostMetrics.Timer("save-latency", nil),
@@ -179,7 +179,7 @@ func (m *countsBySvc) countByServiceName(serviceName string) {
 	if c, ok := m.counts[serviceName]; ok {
 		counter = c
 	} else if len(m.counts) < maxServiceNames {
-		c := m.factory.Counter(serviceName, nil)
+		c := m.factory.Counter("", map[string]string{"service": serviceName})
 		m.counts[serviceName] = c
 		counter = c
 	}

cmd/collector/app/metrics_test.go

@@ -47,8 +47,8 @@ func TestProcessorMetrics(t *testing.T) {
 	jFormat.ReceivedBySvc.ReportServiceNameForSpan(&mSpan)
 	counters, gauges := baseMetrics.LocalBackend.Snapshot()
 
-	assert.EqualValues(t, 2, counters["service.jaeger.spans.by-svc.fry"])
-	assert.EqualValues(t, 1, counters["service.jaeger.traces.by-svc.fry"])
-	assert.EqualValues(t, 1, counters["service.jaeger.debug-spans.by-svc.fry"])
+	assert.EqualValues(t, 2, counters["service.spans.by-svc|format=jaeger|service=fry"])
+	assert.EqualValues(t, 1, counters["service.traces.by-svc|format=jaeger|service=fry"])
+	assert.EqualValues(t, 1, counters["service.debug-spans.by-svc|format=jaeger|service=fry"])
 	assert.Empty(t, gauges)
 }

cmd/collector/app/span_processor_test.go

@@ -85,12 +85,13 @@ func TestBySvcMetrics(t *testing.T) {
 		)
 		ctx := context.Background()
 		tctx := thrift.Wrap(ctx)
-		var metricPrefix string
+		var metricPrefix, format string
 		if test.format == ZipkinFormatType {
 			span := makeZipkinSpan(test.serviceName, test.rootSpan, test.debug)
 			zHandler := NewZipkinSpanHandler(logger, processor, zipkinSanitizer.NewParentIDSanitizer())
 			zHandler.SubmitZipkinBatch(tctx, []*zc.Span{span, span})
-			metricPrefix = "service.zipkin"
+			metricPrefix = "service"
+			format = "zipkin"
 		} else if test.format == JaegerFormatType {
 			span, process := makeJaegerSpan(test.serviceName, test.rootSpan, test.debug)
 			jHandler := NewJaegerSpanHandler(logger, processor)
@@ -103,22 +104,24 @@ func TestBySvcMetrics(t *testing.T) {
 					Process: process,
 				},
 			})
-			metricPrefix = "service.jaeger"
+			metricPrefix = "service"
+			format = "jaeger"
 		} else {
 			panic("Unknown format")
 		}
 		expected := []metricsTest.ExpectedMetric{
-			{Name: metricPrefix + ".spans.recd", Value: 2},
-			{Name: metricPrefix + ".spans.by-svc." + test.serviceName, Value: 2},
+			//
+			{Name: metricPrefix + ".spans.recd|format=" + format, Value: 2},
+			{Name: metricPrefix + ".spans.by-svc|format=" + format + "|service=" + test.serviceName, Value: 2},
 		}
 		if test.debug {
 			expected = append(expected, metricsTest.ExpectedMetric{
-				Name: metricPrefix + ".debug-spans.by-svc." + test.serviceName, Value: 2,
+				Name: metricPrefix + ".debug-spans.by-svc|format=" + format + "|service=" + test.serviceName, Value: 2,
 			})
 		}
 		if test.rootSpan {
 			expected = append(expected, metricsTest.ExpectedMetric{
-				Name: metricPrefix + ".traces.by-svc." + test.serviceName, Value: 2,
+				Name: metricPrefix + ".traces.by-svc|format=" + format + "|service=" + test.serviceName, Value: 2,
 			})
 		}
 		if test.serviceName != blackListedService || test.debug {
@@ -133,7 +136,7 @@ func TestBySvcMetrics(t *testing.T) {
 			})
 		} else {
 			expected = append(expected, metricsTest.ExpectedMetric{
-				Name: metricPrefix + ".spans.rejected", Value: 2,
+				Name: metricPrefix + ".spans.rejected|format=" + format, Value: 2,
 			})
 		}
 		metricsTest.AssertCounterMetrics(t, mb, expected...)

cmd/collector/main.go

@@ -92,20 +92,21 @@ func main() {
 			}
 
 			mBldr := new(pMetrics.Builder).InitFromViper(v)
-			metricsFactory, err := mBldr.CreateMetricsFactory("jaeger-collector")
+			baseFactory, err := mBldr.CreateMetricsFactory("jaeger")
 			if err != nil {
 				logger.Fatal("Cannot create metrics factory.", zap.Error(err))
 			}
 
 			storageFactory.InitFromViper(v)
-			if err := storageFactory.Initialize(metricsFactory, logger); err != nil {
+			if err := storageFactory.Initialize(baseFactory, logger); err != nil {
 				logger.Fatal("Failed to init storage factory", zap.Error(err))
 			}
 			spanWriter, err := storageFactory.CreateSpanWriter()
 			if err != nil {
 				logger.Fatal("Failed to create span writer", zap.Error(err))
 			}
 
+			metricsFactory := baseFactory.Namespace("collector", nil)
 			handlerBuilder, err := builder.NewSpanHandlerBuilder(
 				builderOpts,
 				spanWriter,

cmd/query/main.go

@@ -77,7 +77,7 @@ func main() {
 			}
 
 			mBldr := new(pMetrics.Builder).InitFromViper(v)
-			metricsFactory, err := mBldr.CreateMetricsFactory("jaeger-query")
+			baseFactory, err := mBldr.CreateMetricsFactory("jaeger")
 			if err != nil {
 				logger.Fatal("Cannot create metrics factory.", zap.Error(err))
 			}
@@ -88,14 +88,14 @@ func main() {
 					Param: 1.0,
 				},
 				RPCMetrics: true,
-			}.New("jaeger-query", jaegerClientConfig.Metrics(metricsFactory))
+			}.New("jaeger-query", jaegerClientConfig.Metrics(baseFactory.Namespace("client", nil)))
 			if err != nil {
 				logger.Fatal("Failed to initialize tracer", zap.Error(err))
 			}
 			defer closer.Close()
 
 			storageFactory.InitFromViper(v)
-			if err := storageFactory.Initialize(metricsFactory, logger); err != nil {
+			if err := storageFactory.Initialize(baseFactory, logger); err != nil {
 				logger.Fatal("Failed to init storage factory", zap.Error(err))
 			}
 			spanReader, err := storageFactory.CreateSpanReader()

cmd/standalone/main.go

@@ -91,7 +91,7 @@ func main() {
 			}
 
 			mBldr := new(pMetrics.Builder).InitFromViper(v)
-			metricsFactory, err := mBldr.CreateMetricsFactory("jaeger-standalone")
+			metricsFactory, err := mBldr.CreateMetricsFactory("jaeger")
 			if err != nil {
 				return errors.Wrap(err, "Cannot create metrics factory")
 			}
@@ -158,7 +158,7 @@ func startAgent(
 	logger *zap.Logger,
 	baseFactory metrics.Factory,
 ) {
-	metricsFactory := baseFactory.Namespace("jaeger-agent", nil)
+	metricsFactory := baseFactory.Namespace("agent", nil)
 
 	if len(b.CollectorHostPorts) == 0 {
 		b.CollectorHostPorts = append(b.CollectorHostPorts, fmt.Sprintf("127.0.0.1:%d", cOpts.CollectorPort))
@@ -181,7 +181,7 @@ func startCollector(
 	baseFactory metrics.Factory,
 	samplingHandler sampling.Handler,
 ) {
-	metricsFactory := baseFactory.Namespace("jaeger-collector", nil)
+	metricsFactory := baseFactory.Namespace("collector", nil)
 
 	spanBuilder, err := collector.NewSpanHandlerBuilder(
 		cOpts,
@@ -259,7 +259,7 @@ func startQuery(
 			Param: 1.0,
 		},
 		RPCMetrics: true,
-	}.New("jaeger-query", jaegerClientConfig.Metrics(baseFactory))
+	}.New("jaeger-query", jaegerClientConfig.Metrics(baseFactory.Namespace("client", nil)))
 	if err != nil {
 		logger.Fatal("Failed to initialize tracer", zap.Error(err))
 	}

glide.yaml

@@ -17,7 +17,7 @@ import:
   subpackages:
   - transport
 - package: github.com/uber/jaeger-lib
-  version: ^1.4.0
+  version: fe748a21c8698beaae2a738e4e1d0b6ba53b254f
 - package: github.com/uber/tchannel-go
   version: v1.1.0
   subpackages:

pkg/cassandra/metrics/table.go

@@ -33,7 +33,7 @@ type Table struct {
 // NewTable takes a metrics scope and creates a table metrics struct
 func NewTable(factory metrics.Factory, tableName string) *Table {
 	t := storageMetrics.WriteMetrics{}
-	metrics.Init(&t, factory.Namespace(tableName, nil), nil)
+	metrics.Init(&t, factory.Namespace("", map[string]string{"table": tableName}), nil)
 	return &Table{t}
 }
 

pkg/cassandra/metrics/table_test.go

@@ -34,31 +34,31 @@ func TestTableEmit(t *testing.T) {
 		{
 			err: nil,
 			counts: map[string]int64{
-				"a_table.attempts": 1,
-				"a_table.inserts":  1,
+				"attempts|table=a_table": 1,
+				"inserts|table=a_table":  1,
 			},
 			gauges: map[string]int64{
-				"a_table.latency-ok.P999": 51,
-				"a_table.latency-ok.P50":  51,
-				"a_table.latency-ok.P75":  51,
-				"a_table.latency-ok.P90":  51,
-				"a_table.latency-ok.P95":  51,
-				"a_table.latency-ok.P99":  51,
+				"latency-ok|table=a_table.P999": 51,
+				"latency-ok|table=a_table.P50":  51,
+				"latency-ok|table=a_table.P75":  51,
+				"latency-ok|table=a_table.P90":  51,
+				"latency-ok|table=a_table.P95":  51,
+				"latency-ok|table=a_table.P99":  51,
 			},
 		},
 		{
 			err: errors.New("some error"),
 			counts: map[string]int64{
-				"a_table.attempts": 1,
-				"a_table.errors":   1,
+				"attempts|table=a_table": 1,
+				"errors|table=a_table":   1,
 			},
 			gauges: map[string]int64{
-				"a_table.latency-err.P999": 51,
-				"a_table.latency-err.P50":  51,
-				"a_table.latency-err.P75":  51,
-				"a_table.latency-err.P90":  51,
-				"a_table.latency-err.P95":  51,
-				"a_table.latency-err.P99":  51,
+				"latency-err|table=a_table.P999": 51,
+				"latency-err|table=a_table.P50":  51,
+				"latency-err|table=a_table.P75":  51,
+				"latency-err|table=a_table.P90":  51,
+				"latency-err|table=a_table.P95":  51,
+				"latency-err|table=a_table.P99":  51,
 			},
 		},
 	}
@@ -82,8 +82,8 @@ func TestTableExec(t *testing.T) {
 		{
 			q: insertQuery{},
 			counts: map[string]int64{
-				"a_table.attempts": 1,
-				"a_table.inserts":  1,
+				"attempts|table=a_table": 1,
+				"inserts|table=a_table":  1,
 			},
 		},
 		{
@@ -92,8 +92,8 @@ func TestTableExec(t *testing.T) {
 				err: errors.New("failed"),
 			},
 			counts: map[string]int64{
-				"a_table.attempts": 1,
-				"a_table.errors":   1,
+				"attempts|table=a_table": 1,
+				"errors|table=a_table":   1,
 			},
 		},
 		{
@@ -103,8 +103,8 @@ func TestTableExec(t *testing.T) {
 			},
 			log: true,
 			counts: map[string]int64{
-				"a_table.attempts": 1,
-				"a_table.errors":   1,
+				"attempts|table=a_table": 1,
+				"errors|table=a_table":   1,
 			},
 		},
 	}

pkg/es/config/config.go

@@ -62,7 +62,7 @@ func (c *Configuration) NewClient(logger *zap.Logger, metricsFactory metrics.Fac
 		return nil, err
 	}
 
-	sm := storageMetrics.NewWriteMetrics(metricsFactory, "BulkIndex")
+	sm := storageMetrics.NewWriteMetrics(metricsFactory, "bulk_index")
 	m := sync.Map{}
 
 	service, err := rawClient.BulkProcessor().

pkg/metrics/builder_test.go

@@ -51,7 +51,7 @@ func TestBuilder(t *testing.T) {
 		families, err := prometheus.DefaultGatherer.Gather()
 		require.NoError(t, err)
 		for _, mf := range families {
-			if mf.GetName() == "foo:counter" {
+			if mf.GetName() == "foo_counter" {
 				return
 			}
 		}

plugin/storage/cassandra/dependencystore/storage.go

@@ -49,7 +49,7 @@ func NewDependencyStore(
 	return &DependencyStore{
 		session:                  session,
 		dependencyDataFrequency:  dependencyDataFrequency,
-		dependenciesTableMetrics: casMetrics.NewTable(metricsFactory, "Dependencies"),
+		dependenciesTableMetrics: casMetrics.NewTable(metricsFactory, "dependencies"),
 		logger: logger,
 	}
 }

plugin/storage/cassandra/samplingstore/storage.go

@@ -62,8 +62,8 @@ func New(session cassandra.Session, factory metrics.Factory, logger *zap.Logger)
 	return &SamplingStore{
 		session: session,
 		metrics: samplingStoreMetrics{
-			operationThroughput: casMetrics.NewTable(factory, "OperationThroughput"),
-			probabilities:       casMetrics.NewTable(factory, "Probabilities"),
+			operationThroughput: casMetrics.NewTable(factory, "operation_throughput"),
+			probabilities:       casMetrics.NewTable(factory, "probabilities"),
 		},
 		logger: logger,
 	}

plugin/storage/cassandra/spanstore/operation_names.go

@@ -54,7 +54,7 @@ func NewOperationNamesStorage(
 		session:       session,
 		InsertStmt:    insertOperationName,
 		QueryStmt:     queryOperationNames,
-		metrics:       casMetrics.NewTable(metricsFactory, "OperationNames"),
+		metrics:       casMetrics.NewTable(metricsFactory, "operation_names"),
 		writeCacheTTL: writeCacheTTL,
 		logger:        logger,
 		operationNames: cache.NewLRUWithOptions(

plugin/storage/cassandra/spanstore/operation_names_test.go

@@ -85,7 +85,7 @@ func TestOperationNamesStorageWrite(t *testing.T) {
 
 				counts, _ := s.metricsFactory.Snapshot()
 				assert.Equal(t, map[string]int64{
-					"OperationNames.attempts": 2, "OperationNames.inserts": 1, "OperationNames.errors": 1,
+					"attempts|table=operation_names": 2, "inserts|table=operation_names": 1, "errors|table=operation_names": 1,
 				}, counts, "after first two writes")
 
 				// write again
@@ -96,8 +96,8 @@ func TestOperationNamesStorageWrite(t *testing.T) {
 				expCounts := counts
 				if writeCacheTTL == 0 {
 					// without write cache, the second write must succeed
-					expCounts["OperationNames.attempts"]++
-					expCounts["OperationNames.inserts"]++
+					expCounts["attempts|table=operation_names"]++
+					expCounts["inserts|table=operation_names"]++
 				}
 				assert.Equal(t, expCounts, counts2)
 			})

plugin/storage/cassandra/spanstore/reader.go

@@ -113,7 +113,7 @@ func NewSpanReader(
 	metricsFactory metrics.Factory,
 	logger *zap.Logger,
 ) *SpanReader {
-	readFactory := metricsFactory.Namespace("Read", nil)
+	readFactory := metricsFactory.Namespace("read", nil)
 	serviceNamesStorage := NewServiceNamesStorage(session, 0, metricsFactory, logger)
 	operationNamesStorage := NewOperationNamesStorage(session, 0, metricsFactory, logger)
 	return &SpanReader{
@@ -122,12 +122,12 @@ func NewSpanReader(
 		serviceNamesReader:   serviceNamesStorage.GetServices,
 		operationNamesReader: operationNamesStorage.GetOperations,
 		metrics: spanReaderMetrics{
-			readTraces:                 casMetrics.NewTable(readFactory, "ReadTraces"),
-			queryTrace:                 casMetrics.NewTable(readFactory, "QueryTraces"),
-			queryTagIndex:              casMetrics.NewTable(readFactory, "TagIndex"),
-			queryDurationIndex:         casMetrics.NewTable(readFactory, "DurationIndex"),
-			queryServiceOperationIndex: casMetrics.NewTable(readFactory, "ServiceOperationIndex"),
-			queryServiceNameIndex:      casMetrics.NewTable(readFactory, "ServiceNameIndex"),
+			readTraces:                 casMetrics.NewTable(readFactory, "read_traces"),
+			queryTrace:                 casMetrics.NewTable(readFactory, "query_traces"),
+			queryTagIndex:              casMetrics.NewTable(readFactory, "tag_index"),
+			queryDurationIndex:         casMetrics.NewTable(readFactory, "duration_index"),
+			queryServiceOperationIndex: casMetrics.NewTable(readFactory, "service_operation_index"),
+			queryServiceNameIndex:      casMetrics.NewTable(readFactory, "service_name_index"),
 		},
 		logger: logger,
 	}

plugin/storage/cassandra/spanstore/service_names.go

@@ -53,7 +53,7 @@ func NewServiceNamesStorage(
 		session:       session,
 		InsertStmt:    insertServiceName,
 		QueryStmt:     queryServiceNames,
-		metrics:       casMetrics.NewTable(metricsFactory, "ServiceNames"),
+		metrics:       casMetrics.NewTable(metricsFactory, "service_names"),
 		writeCacheTTL: writeCacheTTL,
 		logger:        logger,
 		serviceNames: cache.NewLRUWithOptions(