diff --git a/Makefile b/Makefile index 5a128492e25..834191d15d3 100644 --- a/Makefile +++ b/Makefile @@ -418,6 +418,7 @@ install-mockery: .PHONY: generate-mocks generate-mocks: install-mockery $(MOCKERY) -all -dir ./pkg/es/ -output ./pkg/es/mocks && rm pkg/es/mocks/ClientBuilder.go + $(MOCKERY) -all -dir ./storage/spanstore/ -output ./storage/spanstore/mocks .PHONY: echo-version echo-version: diff --git a/cmd/collector/app/span_processor.go b/cmd/collector/app/span_processor.go index a0a3db65030..3a568a5d0b7 100644 --- a/cmd/collector/app/span_processor.go +++ b/cmd/collector/app/span_processor.go @@ -16,6 +16,7 @@ package app import ( + "context" "sync" "time" @@ -140,7 +141,8 @@ func (sp *spanProcessor) saveSpan(span *model.Span) { } startTime := time.Now() - if err := sp.spanWriter.WriteSpan(span); err != nil { + // TODO context should be propagated from upstream components + if err := sp.spanWriter.WriteSpan(context.TODO(), span); err != nil { sp.logger.Error("Failed to save span", zap.Error(err)) sp.metrics.SavedErrBySvc.ReportServiceNameForSpan(span) } else { diff --git a/cmd/collector/app/span_processor_test.go b/cmd/collector/app/span_processor_test.go index 118833a954b..ee828ac717b 100644 --- a/cmd/collector/app/span_processor_test.go +++ b/cmd/collector/app/span_processor_test.go @@ -16,6 +16,7 @@ package app import ( + "context" "fmt" "io" "sync" @@ -166,7 +167,7 @@ type fakeSpanWriter struct { err error } -func (n *fakeSpanWriter) WriteSpan(span *model.Span) error { +func (n *fakeSpanWriter) WriteSpan(ctx context.Context, span *model.Span) error { return n.err } @@ -273,7 +274,7 @@ type blockingWriter struct { sync.Mutex } -func (w *blockingWriter) WriteSpan(span *model.Span) error { +func (w *blockingWriter) WriteSpan(ctx context.Context, span *model.Span) error { w.Lock() defer w.Unlock() return nil diff --git a/cmd/ingester/app/processor/span_processor.go b/cmd/ingester/app/processor/span_processor.go index c31eb793182..ad1c8aa7479 100644 --- a/cmd/ingester/app/processor/span_processor.go +++ b/cmd/ingester/app/processor/span_processor.go @@ -15,6 +15,7 @@ package processor import ( + "context" "fmt" "io" @@ -58,9 +59,10 @@ func NewSpanProcessor(params SpanProcessorParams) *KafkaSpanProcessor { // Process unmarshals and writes a single kafka message func (s KafkaSpanProcessor) Process(message Message) error { - mSpan, err := s.unmarshaller.Unmarshal(message.Value()) + span, err := s.unmarshaller.Unmarshal(message.Value()) if err != nil { return fmt.Errorf("cannot unmarshall byte array into span: %w", err) } - return s.writer.WriteSpan(mSpan) + // TODO context should be propagated from upstream components + return s.writer.WriteSpan(context.TODO(), span) } diff --git a/cmd/ingester/app/processor/span_processor_test.go b/cmd/ingester/app/processor/span_processor_test.go index 373aff3be11..91956b78d99 100644 --- a/cmd/ingester/app/processor/span_processor_test.go +++ b/cmd/ingester/app/processor/span_processor_test.go @@ -15,6 +15,7 @@ package processor import ( + "context" "errors" "testing" @@ -45,7 +46,7 @@ func TestSpanProcessor_Process(t *testing.T) { message.On("Value").Return(data) unmarshallerMock.On("Unmarshal", data).Return(span, nil) - writer.On("WriteSpan", span).Return(nil) + writer.On("WriteSpan", context.Background(), span).Return(nil) assert.Nil(t, processor.Process(message)) diff --git a/cmd/opentelemetry/app/exporter/elasticsearchexporter/integration_test.go b/cmd/opentelemetry/app/exporter/elasticsearchexporter/integration_test.go index 32b4193b3cd..c522369ea97 100644 --- a/cmd/opentelemetry/app/exporter/elasticsearchexporter/integration_test.go +++ b/cmd/opentelemetry/app/exporter/elasticsearchexporter/integration_test.go @@ -38,6 +38,7 @@ import ( "github.com/jaegertracing/jaeger/plugin/storage/es" "github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel" "github.com/jaegertracing/jaeger/plugin/storage/integration" + "github.com/jaegertracing/jaeger/storage/spanstore" ) const ( @@ -61,13 +62,15 @@ type storageWrapper struct { writer *esSpanWriter } -func (s storageWrapper) WriteSpan(span *model.Span) error { +var _ spanstore.Writer = (*storageWrapper)(nil) + +func (s storageWrapper) WriteSpan(ctx context.Context, span *model.Span) error { // This fails because there is no binary tag type in OTEL and also OTEL span's status code is always created //traces := jaegertranslator.ProtoBatchesToInternalTraces([]*model.Batch{{Process: span.Process, Spans: []*model.Span{span}}}) //_, err := s.writer.WriteTraces(context.Background(), traces) converter := dbmodel.FromDomain{} dbSpan := converter.FromDomainEmbedProcess(span) - _, err := s.writer.writeSpans(context.Background(), []*dbmodel.Span{dbSpan}) + _, err := s.writer.writeSpans(ctx, []*dbmodel.Span{dbSpan}) return err } diff --git a/cmd/opentelemetry/app/exporter/span_writer_exporter.go b/cmd/opentelemetry/app/exporter/span_writer_exporter.go index f90c431ff1b..e5ad8885b47 100644 --- a/cmd/opentelemetry/app/exporter/span_writer_exporter.go +++ b/cmd/opentelemetry/app/exporter/span_writer_exporter.go @@ -63,7 +63,7 @@ func (s *store) traceDataPusher(ctx context.Context, td pdata.Traces) (droppedSp for _, batch := range batches { for _, span := range batch.Spans { span.Process = batch.Process - err := s.Writer.WriteSpan(span) + err := s.Writer.WriteSpan(ctx, span) if err != nil { errs = append(errs, err) dropped++ diff --git a/cmd/opentelemetry/app/exporter/span_writer_exporter_test.go b/cmd/opentelemetry/app/exporter/span_writer_exporter_test.go index f8a5f65e204..72b9e7d4991 100644 --- a/cmd/opentelemetry/app/exporter/span_writer_exporter_test.go +++ b/cmd/opentelemetry/app/exporter/span_writer_exporter_test.go @@ -125,7 +125,7 @@ type spanWriter struct { err error } -func (w spanWriter) WriteSpan(span *model.Span) error { +func (w spanWriter) WriteSpan(ctx context.Context, span *model.Span) error { if span.GetOperationName() == "error" { return w.err } @@ -139,7 +139,7 @@ func (spanWriter) Close() error { type noClosableWriter struct { } -func (noClosableWriter) WriteSpan(span *model.Span) error { +func (noClosableWriter) WriteSpan(ctx context.Context, span *model.Span) error { return nil } diff --git a/cmd/opentelemetry/app/receiver/kafkareceiver/kafka_receiver.go b/cmd/opentelemetry/app/receiver/kafkareceiver/kafka_receiver.go index c3340e39ee2..c698ef3b662 100644 --- a/cmd/opentelemetry/app/receiver/kafkareceiver/kafka_receiver.go +++ b/cmd/opentelemetry/app/receiver/kafkareceiver/kafka_receiver.go @@ -30,19 +30,27 @@ import ( "github.com/jaegertracing/jaeger/storage/spanstore" ) +var ( + _ spanstore.Writer = (*writer)(nil) + _ component.Receiver = (*kafkaReceiver)(nil) +) + +type kafkaReceiver struct { + logger *zap.Logger + consumer *ingester.Consumer +} + +type writer struct { + receiver string + nextConsumer consumer.TraceConsumer +} + func new( config *Config, nextConsumer consumer.TraceConsumer, params component.ReceiverCreateParams, ) (component.TraceReceiver, error) { - ctx := obsreport.ReceiverContext( - context.Background(), config.Name(), "kafka", "kafka") - ctx = obsreport.StartTraceDataReceiveOp( - ctx, TypeStr, "kafka") - w := &writer{ - ctx: ctx, - nextConsumer: nextConsumer, - } + w := &writer{receiver: config.Name(), nextConsumer: nextConsumer} consumer, err := builder.CreateConsumer( params.Logger, metrics.NullFactory, @@ -57,13 +65,6 @@ func new( }, nil } -type kafkaReceiver struct { - logger *zap.Logger - consumer *ingester.Consumer -} - -var _ component.Receiver = (*kafkaReceiver)(nil) - // Start starts the receiver. func (r kafkaReceiver) Start(_ context.Context, _ component.Host) error { r.consumer.Start() @@ -75,19 +76,20 @@ func (r kafkaReceiver) Shutdown(_ context.Context) error { return r.consumer.Close() } -type writer struct { - nextConsumer consumer.TraceConsumer - ctx context.Context -} - -var _ spanstore.Writer = (*writer)(nil) - // WriteSpan writes a span to the next consumer. -func (w writer) WriteSpan(span *model.Span) error { +func (w writer) WriteSpan(ctx context.Context, span *model.Span) error { batch := model.Batch{ Spans: []*model.Span{span}, Process: span.Process, } traces := jaegertranslator.ProtoBatchToInternalTraces(batch) - return w.nextConsumer.ConsumeTraces(w.ctx, traces) + return w.nextConsumer.ConsumeTraces(w.addContextMetrics(ctx), traces) +} + +// addContextMetrics decorates the context with labels used in metrics later. +func (w writer) addContextMetrics(ctx context.Context) context.Context { + // TODO too many mallocs here, should be a cheaper way + ctx = obsreport.ReceiverContext(ctx, w.receiver, "kafka", "kafka") + ctx = obsreport.StartTraceDataReceiveOp(ctx, TypeStr, "kafka") + return ctx } diff --git a/cmd/query/app/grpc_handler_test.go b/cmd/query/app/grpc_handler_test.go index 68c89f73a52..99a81f7264d 100644 --- a/cmd/query/app/grpc_handler_test.go +++ b/cmd/query/app/grpc_handler_test.go @@ -264,7 +264,7 @@ func TestArchiveTraceSuccessGRPC(t *testing.T) { withServerAndClient(t, func(server *grpcServer, client *grpcClient) { server.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). Return(mockTrace, nil).Once() - server.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*model.Span")). + server.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(nil).Times(2) _, err := client.ArchiveTrace(context.Background(), &api_v2.ArchiveTraceRequest{ @@ -295,7 +295,7 @@ func TestArchiveTraceFailureGRPC(t *testing.T) { server.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). Return(mockTrace, nil).Once() - server.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*model.Span")). + server.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(errStorageGRPC).Times(2) _, err := client.ArchiveTrace(context.Background(), &api_v2.ArchiveTraceRequest{ diff --git a/cmd/query/app/handler_archive_test.go b/cmd/query/app/handler_archive_test.go index c64e9ba9d3f..6f2a99dabf9 100644 --- a/cmd/query/app/handler_archive_test.go +++ b/cmd/query/app/handler_archive_test.go @@ -103,7 +103,7 @@ func TestArchiveTrace_NoStorage(t *testing.T) { func TestArchiveTrace_Success(t *testing.T) { mockWriter := &spanstoremocks.Writer{} - mockWriter.On("WriteSpan", mock.AnythingOfType("*model.Span")). + mockWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(nil).Times(2) withTestServer(t, func(ts *testServer) { ts.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). @@ -116,7 +116,7 @@ func TestArchiveTrace_Success(t *testing.T) { func TestArchiveTrace_WriteErrors(t *testing.T) { mockWriter := &spanstoremocks.Writer{} - mockWriter.On("WriteSpan", mock.AnythingOfType("*model.Span")). + mockWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(errors.New("cannot save")).Times(2) withTestServer(t, func(ts *testServer) { ts.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). diff --git a/cmd/query/app/querysvc/query_service.go b/cmd/query/app/querysvc/query_service.go index c91b52586f8..a65bd5ae74f 100644 --- a/cmd/query/app/querysvc/query_service.go +++ b/cmd/query/app/querysvc/query_service.go @@ -107,7 +107,7 @@ func (qs QueryService) ArchiveTrace(ctx context.Context, traceID model.TraceID) var writeErrors []error for _, span := range trace.Spans { - err := qs.options.ArchiveSpanWriter.WriteSpan(span) + err := qs.options.ArchiveSpanWriter.WriteSpan(ctx, span) if err != nil { writeErrors = append(writeErrors, err) } diff --git a/cmd/query/app/querysvc/query_service_test.go b/cmd/query/app/querysvc/query_service_test.go index e68482ba435..baeb08e4bb4 100644 --- a/cmd/query/app/querysvc/query_service_test.go +++ b/cmd/query/app/querysvc/query_service_test.go @@ -212,7 +212,7 @@ func TestArchiveTraceWithArchiveWriterError(t *testing.T) { qs, readMock, _, _, writeMock := initializeTestServiceWithArchiveOptions() readMock.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). Return(mockTrace, nil).Once() - writeMock.On("WriteSpan", mock.AnythingOfType("*model.Span")). + writeMock.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(errors.New("cannot save")).Times(2) type contextKey string @@ -228,7 +228,7 @@ func TestArchiveTraceSuccess(t *testing.T) { qs, readMock, _, _, writeMock := initializeTestServiceWithArchiveOptions() readMock.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")). Return(mockTrace, nil).Once() - writeMock.On("WriteSpan", mock.AnythingOfType("*model.Span")). + writeMock.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")). Return(nil).Times(2) type contextKey string diff --git a/plugin/storage/badger/dependencystore/storage_test.go b/plugin/storage/badger/dependencystore/storage_test.go index 1141ff04e73..bec5418329b 100644 --- a/plugin/storage/badger/dependencystore/storage_test.go +++ b/plugin/storage/badger/dependencystore/storage_test.go @@ -91,7 +91,7 @@ func TestDependencyReader(t *testing.T) { if j > 0 { s.References = []model.SpanRef{model.NewChildOfRef(s.TraceID, model.SpanID(j-1))} } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) } } diff --git a/plugin/storage/badger/spanstore/read_write_test.go b/plugin/storage/badger/spanstore/read_write_test.go index 7ff708127f8..6cd35a779fa 100644 --- a/plugin/storage/badger/spanstore/read_write_test.go +++ b/plugin/storage/badger/spanstore/read_write_test.go @@ -76,7 +76,7 @@ func TestWriteReadBack(t *testing.T) { }, }, } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) } } @@ -173,7 +173,7 @@ func TestIndexSeeks(t *testing.T) { }, } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) } } @@ -331,7 +331,7 @@ func TestWriteDuplicates(t *testing.T) { StartTime: tid.Add(time.Duration(10)), Duration: time.Duration(i + j), } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) } } @@ -359,7 +359,7 @@ func TestMenuSeeks(t *testing.T) { StartTime: tid.Add(time.Duration(i)), Duration: time.Duration(i + j), } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) } } @@ -435,7 +435,7 @@ func TestPersist(t *testing.T) { StartTime: time.Now(), Duration: time.Duration(1 * time.Hour), } - err := sw.WriteSpan(&s) + err := sw.WriteSpan(context.Background(), &s) assert.NoError(t, err) }) @@ -504,7 +504,7 @@ func writeSpans(sw spanstore.Writer, tags []model.KeyValue, services, operations StartTime: tid.Add(time.Duration(time.Millisecond)), Duration: time.Duration(time.Millisecond * time.Duration(i+j)), } - _ = sw.WriteSpan(&s) + _ = sw.WriteSpan(context.Background(), &s) } } } @@ -688,7 +688,7 @@ func TestRandomTraceID(t *testing.T) { StartTime: time.Now(), Duration: 1 * time.Second, } - err := sw.WriteSpan(&s1) + err := sw.WriteSpan(context.Background(), &s1) assert.NoError(t, err) s2 := model.Span{ @@ -711,7 +711,7 @@ func TestRandomTraceID(t *testing.T) { StartTime: time.Now(), Duration: 1 * time.Second, } - err = sw.WriteSpan(&s2) + err = sw.WriteSpan(context.Background(), &s2) assert.NoError(t, err) params := &spanstore.TraceQueryParameters{ diff --git a/plugin/storage/badger/spanstore/rw_internal_test.go b/plugin/storage/badger/spanstore/rw_internal_test.go index 3919a061448..4fe1985566b 100644 --- a/plugin/storage/badger/spanstore/rw_internal_test.go +++ b/plugin/storage/badger/spanstore/rw_internal_test.go @@ -37,7 +37,7 @@ func TestEncodingTypes(t *testing.T) { rw := NewTraceReader(store, cache) sw.encodingType = jsonEncoding - err := sw.WriteSpan(&testSpan) + err := sw.WriteSpan(context.Background(), &testSpan) assert.NoError(t, err) tr, err := rw.GetTrace(context.Background(), model.TraceID{Low: 0, High: 1}) @@ -54,7 +54,7 @@ func TestEncodingTypes(t *testing.T) { // rw := NewTraceReader(store, cache) sw.encodingType = 0x04 - err := sw.WriteSpan(&testSpan) + err := sw.WriteSpan(context.Background(), &testSpan) assert.EqualError(t, err, "unknown encoding type: 0x04") }) @@ -66,7 +66,7 @@ func TestEncodingTypes(t *testing.T) { sw := NewSpanWriter(store, cache, time.Duration(1*time.Hour), nil) rw := NewTraceReader(store, cache) - err := sw.WriteSpan(&testSpan) + err := sw.WriteSpan(context.Background(), &testSpan) assert.NoError(t, err) startTime := model.TimeAsEpochMicroseconds(testSpan.StartTime) @@ -112,7 +112,7 @@ func TestDuplicateTraceIDDetection(t *testing.T) { for i := 0; i < 32; i++ { testSpan.SpanID = model.SpanID(rand.Uint64()) testSpan.StartTime = origStartTime.Add(time.Duration(rand.Int31n(8000)) * time.Millisecond) - err := sw.WriteSpan(&testSpan) + err := sw.WriteSpan(context.Background(), &testSpan) assert.NoError(t, err) } } diff --git a/plugin/storage/badger/spanstore/writer.go b/plugin/storage/badger/spanstore/writer.go index 9abb77f506b..5b973cc8e69 100644 --- a/plugin/storage/badger/spanstore/writer.go +++ b/plugin/storage/badger/spanstore/writer.go @@ -15,6 +15,7 @@ package spanstore import ( + "context" "encoding/binary" "encoding/json" "fmt" @@ -67,7 +68,7 @@ func NewSpanWriter(db *badger.DB, c *CacheStore, ttl time.Duration, storageClose } // WriteSpan writes the encoded span as well as creates indexes with defined TTL -func (w *SpanWriter) WriteSpan(span *model.Span) error { +func (w *SpanWriter) WriteSpan(ctx context.Context, span *model.Span) error { expireTime := uint64(time.Now().Add(w.ttl).Unix()) startTime := model.TimeAsEpochMicroseconds(span.StartTime) diff --git a/plugin/storage/cassandra/savetracetest/main.go b/plugin/storage/cassandra/savetracetest/main.go index 3916f9a4bc4..0cdfab8ef09 100644 --- a/plugin/storage/cassandra/savetracetest/main.go +++ b/plugin/storage/cassandra/savetracetest/main.go @@ -46,13 +46,13 @@ func main() { } spanStore := cSpanStore.NewSpanWriter(cqlSession, time.Hour*12, noScope, logger) spanReader := cSpanStore.NewSpanReader(cqlSession, noScope, logger) - if err = spanStore.WriteSpan(getSomeSpan()); err != nil { + ctx := context.Background() + if err = spanStore.WriteSpan(ctx, getSomeSpan()); err != nil { logger.Fatal("Failed to save", zap.Error(err)) } else { logger.Info("Saved span", zap.String("spanID", getSomeSpan().SpanID.String())) } s := getSomeSpan() - ctx := context.Background() trace, err := spanReader.GetTrace(ctx, s.TraceID) if err != nil { logger.Fatal("Failed to read", zap.Error(err)) diff --git a/plugin/storage/cassandra/spanstore/writer.go b/plugin/storage/cassandra/spanstore/writer.go index 4a183993e08..33be3075823 100644 --- a/plugin/storage/cassandra/spanstore/writer.go +++ b/plugin/storage/cassandra/spanstore/writer.go @@ -16,6 +16,7 @@ package spanstore import ( + "context" "encoding/json" "fmt" "strings" @@ -135,7 +136,7 @@ func (s *SpanWriter) Close() error { } // WriteSpan saves the span into Cassandra -func (s *SpanWriter) WriteSpan(span *model.Span) error { +func (s *SpanWriter) WriteSpan(ctx context.Context, span *model.Span) error { ds := dbmodel.FromDomain(span) if s.storageMode&storeFlag == storeFlag { if err := s.writeSpan(span, ds); err != nil { diff --git a/plugin/storage/cassandra/spanstore/writer_test.go b/plugin/storage/cassandra/spanstore/writer_test.go index f0ea335f734..ee29f32536e 100644 --- a/plugin/storage/cassandra/spanstore/writer_test.go +++ b/plugin/storage/cassandra/spanstore/writer_test.go @@ -16,6 +16,7 @@ package spanstore import ( + "context" "errors" "fmt" "strings" @@ -209,7 +210,7 @@ func TestSpanWriter(t *testing.T) { w.writer.serviceNamesWriter = func(serviceName string) error { return testCase.serviceNameError } w.writer.operationNamesWriter = func(operation dbmodel.Operation) error { return testCase.serviceNameError } - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) if testCase.expectedError == "" { assert.NoError(t, err) @@ -323,7 +324,7 @@ func TestStorageMode_IndexOnly(t *testing.T) { w.session.On("Query", stringMatcher(serviceOperationIndex), matchEverything()).Return(serviceOperationNameQuery) w.session.On("Query", stringMatcher(durationIndex), matchOnce()).Return(durationNoOperationQuery) - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) serviceNameQuery.AssertExpectations(t) @@ -349,7 +350,7 @@ func TestStorageMode_IndexOnly_WithFilter(t *testing.T) { ServiceName: "service-a", }, } - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) w.session.AssertExpectations(t) w.session.AssertNotCalled(t, "Query", stringMatcher(serviceOperationIndex), matchEverything()) @@ -393,7 +394,7 @@ func TestStorageMode_IndexOnly_FirehoseSpan(t *testing.T) { w.session.On("Query", stringMatcher(serviceNameIndex), matchEverything()).Return(serviceNameQuery) w.session.On("Query", stringMatcher(serviceOperationIndex), matchEverything()).Return(serviceOperationNameQuery) - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) w.session.AssertExpectations(t) w.session.AssertNotCalled(t, "Query", stringMatcher(tagIndex), matchEverything()) @@ -425,7 +426,7 @@ func TestStorageMode_StoreWithoutIndexing(t *testing.T) { spanQuery.On("Exec").Return(nil) w.session.On("Query", stringMatcher(insertSpan), matchEverything()).Return(spanQuery) - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) spanQuery.AssertExpectations(t) diff --git a/plugin/storage/es/spanstore/writer.go b/plugin/storage/es/spanstore/writer.go index 40cad8e3ce6..c7cf714e660 100644 --- a/plugin/storage/es/spanstore/writer.go +++ b/plugin/storage/es/spanstore/writer.go @@ -42,7 +42,6 @@ type serviceWriter func(string, *dbmodel.Span) // SpanWriter is a wrapper around elastic.Client type SpanWriter struct { - ctx context.Context client es.Client logger *zap.Logger writerMetrics spanWriterMetrics // TODO: build functions to wrap around each Do fn @@ -67,12 +66,9 @@ type SpanWriterParams struct { // NewSpanWriter creates a new SpanWriter for use func NewSpanWriter(p SpanWriterParams) *SpanWriter { - ctx := context.Background() - // TODO: Configurable TTL serviceOperationStorage := NewServiceOperationStorage(p.Client, p.Logger, time.Hour*12) return &SpanWriter{ - ctx: ctx, client: p.Client, logger: p.Logger, writerMetrics: spanWriterMetrics{ @@ -132,7 +128,7 @@ func getSpanAndServiceIndexFn(archive, useReadWriteAliases bool, prefix string) } // WriteSpan writes a span and its corresponding service:operation in ElasticSearch -func (s *SpanWriter) WriteSpan(span *model.Span) error { +func (s *SpanWriter) WriteSpan(_ context.Context, span *model.Span) error { spanIndexName, serviceIndexName := s.spanServiceIndex(span.StartTime) jsonSpan := s.spanConverter.FromDomainEmbedProcess(span) if serviceIndexName != "" { diff --git a/plugin/storage/es/spanstore/writer_test.go b/plugin/storage/es/spanstore/writer_test.go index 19c37b59a97..1e1292c33e0 100644 --- a/plugin/storage/es/spanstore/writer_test.go +++ b/plugin/storage/es/spanstore/writer_test.go @@ -163,7 +163,7 @@ func TestSpanWriter_WriteSpan(t *testing.T) { w.client.On("Index").Return(indexService) - err = w.writer.WriteSpan(span) + err = w.writer.WriteSpan(context.Background(), span) if testCase.expectedError == "" { require.NoError(t, err) diff --git a/plugin/storage/grpc/shared/grpc_client.go b/plugin/storage/grpc/shared/grpc_client.go index d3ebabc6401..76205b73ab6 100644 --- a/plugin/storage/grpc/shared/grpc_client.go +++ b/plugin/storage/grpc/shared/grpc_client.go @@ -194,8 +194,8 @@ func (c *grpcClient) FindTraceIDs(ctx context.Context, query *spanstore.TraceQue } // WriteSpan saves the span -func (c *grpcClient) WriteSpan(span *model.Span) error { - _, err := c.writerClient.WriteSpan(context.Background(), &storage_v1.WriteSpanRequest{ +func (c *grpcClient) WriteSpan(ctx context.Context, span *model.Span) error { + _, err := c.writerClient.WriteSpan(ctx, &storage_v1.WriteSpanRequest{ Span: span, }) if err != nil { diff --git a/plugin/storage/grpc/shared/grpc_client_test.go b/plugin/storage/grpc/shared/grpc_client_test.go index 3366b05d95c..2761c19f8e1 100644 --- a/plugin/storage/grpc/shared/grpc_client_test.go +++ b/plugin/storage/grpc/shared/grpc_client_test.go @@ -277,7 +277,7 @@ func TestGRPCClientWriteSpan(t *testing.T) { Span: &mockTraceSpans[0], }).Return(&storage_v1.WriteSpanResponse{}, nil) - err := r.client.WriteSpan(&mockTraceSpans[0]) + err := r.client.WriteSpan(context.Background(), &mockTraceSpans[0]) assert.NoError(t, err) }) } diff --git a/plugin/storage/grpc/shared/grpc_server.go b/plugin/storage/grpc/shared/grpc_server.go index d79df7d6569..4518908c825 100644 --- a/plugin/storage/grpc/shared/grpc_server.go +++ b/plugin/storage/grpc/shared/grpc_server.go @@ -43,7 +43,7 @@ func (s *grpcServer) GetDependencies(ctx context.Context, r *storage_v1.GetDepen // WriteSpan saves the span func (s *grpcServer) WriteSpan(ctx context.Context, r *storage_v1.WriteSpanRequest) (*storage_v1.WriteSpanResponse, error) { - err := s.Impl.SpanWriter().WriteSpan(r.Span) + err := s.Impl.SpanWriter().WriteSpan(ctx, r.Span) if err != nil { return nil, err } diff --git a/plugin/storage/grpc/shared/grpc_server_test.go b/plugin/storage/grpc/shared/grpc_server_test.go index 59fe23ee161..17b39367b3b 100644 --- a/plugin/storage/grpc/shared/grpc_server_test.go +++ b/plugin/storage/grpc/shared/grpc_server_test.go @@ -177,7 +177,7 @@ func TestGRPCServerFindTraceIDs(t *testing.T) { func TestGRPCServerWriteSpan(t *testing.T) { withGRPCServer(func(r *grpcServerTest) { - r.impl.spanWriter.On("WriteSpan", &mockTraceSpans[0]). + r.impl.spanWriter.On("WriteSpan", context.Background(), &mockTraceSpans[0]). Return(nil) s, err := r.server.WriteSpan(context.Background(), &storage_v1.WriteSpanRequest{ diff --git a/plugin/storage/integration/elasticsearch_test.go b/plugin/storage/integration/elasticsearch_test.go index c55a96b311f..6bd0de3f3f5 100644 --- a/plugin/storage/integration/elasticsearch_test.go +++ b/plugin/storage/integration/elasticsearch_test.go @@ -203,7 +203,7 @@ func (s *StorageIntegration) testArchiveTrace(t *testing.T) { Process: model.NewProcess("archived_service", model.KeyValues{}), } - require.NoError(t, s.SpanWriter.WriteSpan(expected)) + require.NoError(t, s.SpanWriter.WriteSpan(context.Background(), expected)) s.refresh(t) var actual *model.Trace diff --git a/plugin/storage/integration/integration.go b/plugin/storage/integration/integration.go index 8f5382c05d7..8887b75b49e 100644 --- a/plugin/storage/integration/integration.go +++ b/plugin/storage/integration/integration.go @@ -245,7 +245,7 @@ func (s *StorageIntegration) findTracesByQuery(t *testing.T, query *spanstore.Tr func (s *StorageIntegration) writeTrace(t *testing.T, trace *model.Trace) error { for _, span := range trace.Spans { - if err := s.SpanWriter.WriteSpan(span); err != nil { + if err := s.SpanWriter.WriteSpan(context.Background(), span); err != nil { return err } } diff --git a/plugin/storage/kafka/writer.go b/plugin/storage/kafka/writer.go index dbb84fb1945..e82ecea735c 100644 --- a/plugin/storage/kafka/writer.go +++ b/plugin/storage/kafka/writer.go @@ -15,6 +15,8 @@ package kafka import ( + "context" + "github.com/Shopify/sarama" "github.com/uber/jaeger-lib/metrics" "go.uber.org/zap" @@ -69,7 +71,7 @@ func NewSpanWriter( } // WriteSpan writes the span to kafka. -func (w *SpanWriter) WriteSpan(span *model.Span) error { +func (w *SpanWriter) WriteSpan(ctx context.Context, span *model.Span) error { spanBytes, err := w.marshaller.Marshal(span) if err != nil { w.metrics.SpansWrittenFailure.Inc(1) diff --git a/plugin/storage/kafka/writer_test.go b/plugin/storage/kafka/writer_test.go index 51a36cc916f..7a35b55da94 100644 --- a/plugin/storage/kafka/writer_test.go +++ b/plugin/storage/kafka/writer_test.go @@ -15,6 +15,7 @@ package kafka import ( + "context" "errors" "testing" "time" @@ -97,7 +98,7 @@ func TestKafkaWriter(t *testing.T) { w.producer.ExpectInputAndSucceed() - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) for i := 0; i < 100; i++ { @@ -129,7 +130,7 @@ func TestKafkaWriterErr(t *testing.T) { withSpanWriter(t, func(span *model.Span, w *spanWriterTest) { w.producer.ExpectInputAndFail(sarama.ErrRequestTimedOut) - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.NoError(t, err) for i := 0; i < 100; i++ { @@ -164,7 +165,7 @@ func TestMarshallerErr(t *testing.T) { marshaller.On("Marshal", mock.AnythingOfType("*model.Span")).Return([]byte{}, errors.New("")) w.writer.marshaller = marshaller - err := w.writer.WriteSpan(span) + err := w.writer.WriteSpan(context.Background(), span) assert.Error(t, err) w.writer.Close() diff --git a/plugin/storage/memory/memory.go b/plugin/storage/memory/memory.go index fa11dcc9dbb..ee5e1643cee 100644 --- a/plugin/storage/memory/memory.go +++ b/plugin/storage/memory/memory.go @@ -114,7 +114,7 @@ func (m *Store) traceIsBetweenStartAndEnd(startTs, endTs time.Time, trace *model } // WriteSpan writes the given span -func (m *Store) WriteSpan(span *model.Span) error { +func (m *Store) WriteSpan(ctx context.Context, span *model.Span) error { m.Lock() defer m.Unlock() if _, ok := m.operations[span.Process.ServiceName]; !ok { diff --git a/plugin/storage/memory/memory_test.go b/plugin/storage/memory/memory_test.go index fb847b6a044..104e41a41c4 100644 --- a/plugin/storage/memory/memory_test.go +++ b/plugin/storage/memory/memory_test.go @@ -130,7 +130,7 @@ var childSpan2_1 = &model.Span{ func withPopulatedMemoryStore(f func(store *Store)) { memStore := NewStore() - memStore.WriteSpan(testingSpan) + memStore.WriteSpan(context.Background(), testingSpan) f(memStore) } func withMemoryStore(f func(store *Store)) { @@ -147,10 +147,10 @@ func TestStoreGetEmptyDependencies(t *testing.T) { func TestStoreGetDependencies(t *testing.T) { withMemoryStore(func(store *Store) { - assert.NoError(t, store.WriteSpan(testingSpan)) - assert.NoError(t, store.WriteSpan(childSpan1)) - assert.NoError(t, store.WriteSpan(childSpan2)) - assert.NoError(t, store.WriteSpan(childSpan2_1)) + assert.NoError(t, store.WriteSpan(context.Background(), testingSpan)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan1)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2_1)) links, err := store.GetDependencies(context.Background(), time.Now(), time.Hour) assert.NoError(t, err) assert.Empty(t, links) @@ -167,7 +167,7 @@ func TestStoreGetDependencies(t *testing.T) { func TestStoreWriteSpan(t *testing.T) { withMemoryStore(func(store *Store) { - err := store.WriteSpan(testingSpan) + err := store.WriteSpan(context.Background(), testingSpan) assert.NoError(t, err) }) } @@ -178,7 +178,7 @@ func TestStoreWithLimit(t *testing.T) { for i := 0; i < maxTraces*2; i++ { id := model.NewTraceID(1, uint64(i)) - err := store.WriteSpan(&model.Span{ + err := store.WriteSpan(context.Background(), &model.Span{ TraceID: id, Process: &model.Process{ ServiceName: "TestStoreWithLimit", @@ -186,7 +186,7 @@ func TestStoreWithLimit(t *testing.T) { }) assert.NoError(t, err) - err = store.WriteSpan(&model.Span{ + err = store.WriteSpan(context.Background(), &model.Span{ TraceID: id, SpanID: model.NewSpanID(uint64(i)), Process: &model.Process{ @@ -229,10 +229,10 @@ func TestStoreGetServices(t *testing.T) { func TestStoreGetAllOperationsFound(t *testing.T) { withPopulatedMemoryStore(func(store *Store) { - assert.NoError(t, store.WriteSpan(testingSpan)) - assert.NoError(t, store.WriteSpan(childSpan1)) - assert.NoError(t, store.WriteSpan(childSpan2)) - assert.NoError(t, store.WriteSpan(childSpan2_1)) + assert.NoError(t, store.WriteSpan(context.Background(), testingSpan)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan1)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2_1)) operations, err := store.GetOperations( context.Background(), spanstore.OperationQueryParameters{ServiceName: childSpan1.Process.ServiceName}, @@ -245,10 +245,10 @@ func TestStoreGetAllOperationsFound(t *testing.T) { func TestStoreGetServerOperationsFound(t *testing.T) { withPopulatedMemoryStore(func(store *Store) { - assert.NoError(t, store.WriteSpan(testingSpan)) - assert.NoError(t, store.WriteSpan(childSpan1)) - assert.NoError(t, store.WriteSpan(childSpan2)) - assert.NoError(t, store.WriteSpan(childSpan2_1)) + assert.NoError(t, store.WriteSpan(context.Background(), testingSpan)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan1)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2)) + assert.NoError(t, store.WriteSpan(context.Background(), childSpan2_1)) expected := []spanstore.Operation{ {Name: childSpan1.OperationName, SpanKind: "server"}, } @@ -315,7 +315,7 @@ func TestStoreFindTracesLimitGetsMostRecent(t *testing.T) { memStore := NewStore() for _, span := range spans { - memStore.WriteSpan(span) + memStore.WriteSpan(context.Background(), span) } gotTraces, err := memStore.FindTraces(context.Background(), &spanstore.TraceQueryParameters{ diff --git a/storage/spanstore/composite.go b/storage/spanstore/composite.go index b1b6516de76..5746d09b925 100644 --- a/storage/spanstore/composite.go +++ b/storage/spanstore/composite.go @@ -16,6 +16,8 @@ package spanstore import ( + "context" + "github.com/jaegertracing/jaeger/model" "github.com/jaegertracing/jaeger/pkg/multierror" ) @@ -33,10 +35,10 @@ func NewCompositeWriter(spanWriters ...Writer) *CompositeWriter { } // WriteSpan calls WriteSpan on each span writer. It will sum up failures, it is not transactional -func (c *CompositeWriter) WriteSpan(span *model.Span) error { +func (c *CompositeWriter) WriteSpan(ctx context.Context, span *model.Span) error { var errors []error for _, writer := range c.spanWriters { - if err := writer.WriteSpan(span); err != nil { + if err := writer.WriteSpan(ctx, span); err != nil { errors = append(errors, err) } } diff --git a/storage/spanstore/composite_test.go b/storage/spanstore/composite_test.go index 34fdd40bc44..ec7aa8cd661 100644 --- a/storage/spanstore/composite_test.go +++ b/storage/spanstore/composite_test.go @@ -16,6 +16,7 @@ package spanstore_test import ( + "context" "errors" "fmt" "testing" @@ -30,27 +31,27 @@ var errIWillAlwaysFail = errors.New("ErrProneWriteSpanStore will always fail") type errProneWriteSpanStore struct{} -func (e *errProneWriteSpanStore) WriteSpan(span *model.Span) error { +func (e *errProneWriteSpanStore) WriteSpan(ctx context.Context, span *model.Span) error { return errIWillAlwaysFail } type noopWriteSpanStore struct{} -func (n *noopWriteSpanStore) WriteSpan(span *model.Span) error { +func (n *noopWriteSpanStore) WriteSpan(ctx context.Context, span *model.Span) error { return nil } func TestCompositeWriteSpanStoreSuccess(t *testing.T) { c := NewCompositeWriter(&noopWriteSpanStore{}, &noopWriteSpanStore{}) - assert.NoError(t, c.WriteSpan(nil)) + assert.NoError(t, c.WriteSpan(context.Background(), nil)) } func TestCompositeWriteSpanStoreSecondFailure(t *testing.T) { c := NewCompositeWriter(&errProneWriteSpanStore{}, &errProneWriteSpanStore{}) - assert.EqualError(t, c.WriteSpan(nil), fmt.Sprintf("[%s, %s]", errIWillAlwaysFail, errIWillAlwaysFail)) + assert.EqualError(t, c.WriteSpan(context.Background(), nil), fmt.Sprintf("[%s, %s]", errIWillAlwaysFail, errIWillAlwaysFail)) } func TestCompositeWriteSpanStoreFirstFailure(t *testing.T) { c := NewCompositeWriter(&errProneWriteSpanStore{}, &noopWriteSpanStore{}) - assert.Equal(t, errIWillAlwaysFail, c.WriteSpan(nil)) + assert.Equal(t, errIWillAlwaysFail, c.WriteSpan(context.Background(), nil)) } diff --git a/storage/spanstore/downsampling_writer.go b/storage/spanstore/downsampling_writer.go index f53105d5d8a..fda95782734 100644 --- a/storage/spanstore/downsampling_writer.go +++ b/storage/spanstore/downsampling_writer.go @@ -15,6 +15,7 @@ package spanstore import ( + "context" "hash" "hash/fnv" "math" @@ -70,14 +71,14 @@ func NewDownsamplingWriter(spanWriter Writer, downsamplingOptions DownsamplingOp } // WriteSpan calls WriteSpan on wrapped span writer. -func (ds *DownsamplingWriter) WriteSpan(span *model.Span) error { +func (ds *DownsamplingWriter) WriteSpan(ctx context.Context, span *model.Span) error { if !ds.sampler.ShouldSample(span) { // Drops spans when hashVal falls beyond computed threshold. ds.metrics.SpansDropped.Inc(1) return nil } ds.metrics.SpansAccepted.Inc(1) - return ds.spanWriter.WriteSpan(span) + return ds.spanWriter.WriteSpan(ctx, span) } // hashBytes returns the uint64 hash value of byte slice. diff --git a/storage/spanstore/downsampling_writer_benchmark_test.go b/storage/spanstore/downsampling_writer_benchmark_test.go index d2580e69087..bfc66c544be 100644 --- a/storage/spanstore/downsampling_writer_benchmark_test.go +++ b/storage/spanstore/downsampling_writer_benchmark_test.go @@ -15,6 +15,7 @@ package spanstore import ( + "context" "fmt" "math" "math/rand" @@ -42,7 +43,7 @@ func BenchmarkDownSamplingWriter_WriteSpan(b *testing.B) { b.ResetTimer() b.ReportAllocs() for it := 0; it < b.N; it++ { - c.WriteSpan(span) + c.WriteSpan(context.Background(), span) } } diff --git a/storage/spanstore/downsampling_writer_test.go b/storage/spanstore/downsampling_writer_test.go index e1463d00da5..de25b68443b 100644 --- a/storage/spanstore/downsampling_writer_test.go +++ b/storage/spanstore/downsampling_writer_test.go @@ -15,6 +15,7 @@ package spanstore import ( + "context" "errors" "math" "testing" @@ -26,7 +27,7 @@ import ( type noopWriteSpanStore struct{} -func (n *noopWriteSpanStore) WriteSpan(span *model.Span) error { +func (n *noopWriteSpanStore) WriteSpan(ct context.Context, span *model.Span) error { return nil } @@ -34,7 +35,7 @@ var errIWillAlwaysFail = errors.New("ErrProneWriteSpanStore will always fail") type errorWriteSpanStore struct{} -func (n *errorWriteSpanStore) WriteSpan(span *model.Span) error { +func (n *errorWriteSpanStore) WriteSpan(ctx context.Context, span *model.Span) error { return errIWillAlwaysFail } @@ -52,11 +53,11 @@ func TestDownSamplingWriter_WriteSpan(t *testing.T) { HashSalt: "jaeger-test", } c := NewDownsamplingWriter(&errorWriteSpanStore{}, downsamplingOptions) - assert.NoError(t, c.WriteSpan(span)) + assert.NoError(t, c.WriteSpan(context.Background(), span)) downsamplingOptions.Ratio = 1 c = NewDownsamplingWriter(&errorWriteSpanStore{}, downsamplingOptions) - assert.Error(t, c.WriteSpan(span)) + assert.Error(t, c.WriteSpan(context.Background(), span)) } // This test is to make sure h.hash.Reset() works and same traceID will always hash to the same value. diff --git a/storage/spanstore/interface.go b/storage/spanstore/interface.go index 207bc6c64f2..e383da1b0d2 100644 --- a/storage/spanstore/interface.go +++ b/storage/spanstore/interface.go @@ -23,16 +23,16 @@ import ( "github.com/jaegertracing/jaeger/model" ) -// Writer writes spans to storage. -type Writer interface { - WriteSpan(span *model.Span) error -} - var ( // ErrTraceNotFound is returned by Reader's GetTrace if no data is found for given trace ID. ErrTraceNotFound = errors.New("trace not found") ) +// Writer writes spans to storage. +type Writer interface { + WriteSpan(ctx context.Context, span *model.Span) error +} + // Reader finds and loads traces and other data from storage. type Reader interface { GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) diff --git a/storage/spanstore/mocks/Reader.go b/storage/spanstore/mocks/Reader.go index be9377e0a45..a4bfcb02a7e 100644 --- a/storage/spanstore/mocks/Reader.go +++ b/storage/spanstore/mocks/Reader.go @@ -1,5 +1,6 @@ -// Copyright (c) 2019 The Jaeger Authors. -// Copyright (c) 2017 Uber Technologies, Inc. +// Code generated by mockery v1.0.0. DO NOT EDIT. + +// Copyright (c) 2020 The Jaeger Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,14 +14,17 @@ // See the License for the specific language governing permissions and // limitations under the License. + package mocks import ( - "context" + context "context" + + mock "github.com/stretchr/testify/mock" + + model "github.com/jaegertracing/jaeger/model" + spanstore "github.com/jaegertracing/jaeger/storage/spanstore" ) -import "github.com/stretchr/testify/mock" -import "github.com/jaegertracing/jaeger/model" -import "github.com/jaegertracing/jaeger/storage/spanstore" // Reader is an autogenerated mock type for the Reader type type Reader struct { @@ -74,17 +78,11 @@ func (_m *Reader) FindTraces(ctx context.Context, query *spanstore.TraceQueryPar } // GetOperations provides a mock function with given fields: ctx, query -func (_m *Reader) GetOperations( - ctx context.Context, - query spanstore.OperationQueryParameters, -) ([]spanstore.Operation, error) { +func (_m *Reader) GetOperations(ctx context.Context, query spanstore.OperationQueryParameters) ([]spanstore.Operation, error) { ret := _m.Called(ctx, query) var r0 []spanstore.Operation - if rf, ok := ret.Get(0).(func( - context.Context, - spanstore.OperationQueryParameters, - ) []spanstore.Operation); ok { + if rf, ok := ret.Get(0).(func(context.Context, spanstore.OperationQueryParameters) []spanstore.Operation); ok { r0 = rf(ctx, query) } else { if ret.Get(0) != nil { diff --git a/storage/spanstore/mocks/Writer.go b/storage/spanstore/mocks/Writer.go index 2407e39fe43..8cb093882c7 100644 --- a/storage/spanstore/mocks/Writer.go +++ b/storage/spanstore/mocks/Writer.go @@ -1,5 +1,6 @@ -// Copyright (c) 2019 The Jaeger Authors. -// Copyright (c) 2017 Uber Technologies, Inc. +// Code generated by mockery v1.0.0. DO NOT EDIT. + +// Copyright (c) 2020 The Jaeger Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,29 +14,32 @@ // See the License for the specific language governing permissions and // limitations under the License. + package mocks -import mock "github.com/stretchr/testify/mock" -import model "github.com/jaegertracing/jaeger/model" -import spanstore "github.com/jaegertracing/jaeger/storage/spanstore" +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + model "github.com/jaegertracing/jaeger/model" +) // Writer is an autogenerated mock type for the Writer type type Writer struct { mock.Mock } -// WriteSpan provides a mock function with given fields: span -func (_m *Writer) WriteSpan(span *model.Span) error { - ret := _m.Called(span) +// WriteSpan provides a mock function with given fields: ctx, span +func (_m *Writer) WriteSpan(ctx context.Context, span *model.Span) error { + ret := _m.Called(ctx, span) var r0 error - if rf, ok := ret.Get(0).(func(*model.Span) error); ok { - r0 = rf(span) + if rf, ok := ret.Get(0).(func(context.Context, *model.Span) error); ok { + r0 = rf(ctx, span) } else { r0 = ret.Error(0) } return r0 } - -var _ spanstore.Writer = (*Writer)(nil)