fix: Update gocql instrumentation to meet latest contrib requirements (#298)

* fix: change options to accept providers

* fix: include semver in instrumentation creation

* fix: lint

* fix: Change WithTraceProvider to WithTracerProvider

Co-authored-by: Tyler Yahn <[email protected]>

Author: reggiemcdonald

instrumentation/github.com/gocql/gocql/README.md

@@ -18,13 +18,15 @@ import (
 	"github.com/gocql/gocql"
 
 	"go.opentelemetry.io/otel/api/global"
+	"go.opentelemetry.io/otel/api/metric"
 	"go.opentelemetry.io/otel/api/trace"
 )
 
 // TracedSessionConfig provides configuration for sessions
 // created with NewSessionWithTracing.
 type TracedSessionConfig struct {
-	tracer            trace.Tracer
+	tracerProvider    trace.Provider
+	meterProvider     metric.Provider
 	instrumentQuery   bool
 	instrumentBatch   bool
 	instrumentConnect bool
@@ -78,12 +80,20 @@ func WithConnectObserver(observer gocql.ConnectObserver) TracedSessionOption {
 	})
 }
 
-// WithTracer will set tracer to be the tracer used to create spans
-// for query, batch query, and connection instrumentation.
-// Defaults to global.Tracer("go.opentelemetry.io/contrib/instrumentation/github.com/gocql/gocql").
-func WithTracer(tracer trace.Tracer) TracedSessionOption {
+// WithTracerProvider will set the trace provider used to get a tracer
+// for creating spans. Defaults to global.TraceProvider()
+func WithTracerProvider(provider trace.Provider) TracedSessionOption {
 	return TracedSessionOptionFunc(func(c *TracedSessionConfig) {
-		c.tracer = tracer
+		c.tracerProvider = provider
+	})
+}
+
+// WithMeterProvider will set the meter provider used to get a meter
+// for creating instruments.
+// Defaults to global.MeterProvider().
+func WithMeterProvider(provider metric.Provider) TracedSessionOption {
+	return TracedSessionOptionFunc(func(c *TracedSessionConfig) {
+		c.meterProvider = provider
 	})
 }
 
@@ -115,7 +125,8 @@ func WithConnectInstrumentation(enabled bool) TracedSessionOption {
 
 func configure(options ...TracedSessionOption) *TracedSessionConfig {
 	config := &TracedSessionConfig{
-		tracer:            global.Tracer(instrumentationName),
+		tracerProvider:    global.TraceProvider(),
+		meterProvider:     global.MeterProvider(),
 		instrumentQuery:   true,
 		instrumentBatch:   true,
 		instrumentConnect: true,

instrumentation/github.com/gocql/gocql/config.go

@@ -110,7 +110,7 @@ func main() {
 
 func initMetrics() {
 	// Start prometheus
-	metricExporter, err := prometheus.NewExportPipeline(prometheus.Config{})
+	metricExporter, err := prometheus.InstallNewPipeline(prometheus.Config{})
 	if err != nil {
 		log.Fatalf("failed to install metric exporter, %v", err)
 	}
@@ -133,8 +133,6 @@ func initMetrics() {
 			log.Print("gracefully shutting down server")
 		}
 	}()
-
-	otelGocql.InstrumentWithProvider(metricExporter.Provider())
 }
 
 func initTracer() {

instrumentation/github.com/gocql/gocql/example/client.go

@@ -0,0 +1,41 @@
+// Copyright The OpenTelemetry Authors
+//
+// 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 gocql
+
+import (
+	"context"
+	"log"
+
+	"github.com/gocql/gocql"
+)
+
+func ExampleNewSessionWithTracing() {
+	// Create a cluster
+	host := "localhost"
+	cluster := gocql.NewCluster(host)
+
+	// Create a session with tracing
+	_, err := NewSessionWithTracing(
+		context.Background(),
+		cluster,
+		// Include any options here
+	)
+
+	if err != nil {
+		log.Fatalf("failed to create session, %v", err)
+	}
+
+	// Begin using the session
+}

instrumentation/github.com/gocql/gocql/example_session_test.go

@@ -18,28 +18,39 @@ import (
 	"context"
 
 	"github.com/gocql/gocql"
+
+	otelcontrib "go.opentelemetry.io/contrib"
+	"go.opentelemetry.io/otel/api/trace"
 )
 
 // NewSessionWithTracing creates a new session using the given cluster
 // configuration enabling tracing for queries, batch queries, and connection attempts.
 // You may use additional observers and disable specific tracing using the provided `TracedSessionOption`s.
 func NewSessionWithTracing(ctx context.Context, cluster *gocql.ClusterConfig, options ...TracedSessionOption) (*gocql.Session, error) {
 	config := configure(options...)
+	instruments := newInstruments(config.meterProvider)
+	tracer := config.tracerProvider.Tracer(
+		instrumentationName,
+		trace.WithInstrumentationVersion(otelcontrib.SemVersion()),
+	)
 	cluster.QueryObserver = &OTelQueryObserver{
 		enabled:  config.instrumentQuery,
 		observer: config.queryObserver,
-		tracer:   config.tracer,
+		tracer:   tracer,
+		inst:     instruments,
 	}
 	cluster.BatchObserver = &OTelBatchObserver{
 		enabled:  config.instrumentBatch,
 		observer: config.batchObserver,
-		tracer:   config.tracer,
+		tracer:   tracer,
+		inst:     instruments,
 	}
 	cluster.ConnectObserver = &OTelConnectObserver{
 		ctx:      ctx,
 		enabled:  config.instrumentConnect,
 		observer: config.connectObserver,
-		tracer:   config.tracer,
+		tracer:   tracer,
+		inst:     instruments,
 	}
 	return cluster.CreateSession()
 }

instrumentation/github.com/gocql/gocql/gocql.go

@@ -89,6 +89,20 @@ func mockExportPipeline(t *testing.T) *push.Controller {
 	return controller
 }
 
+type mockTracerProvider struct {
+	tracer *mocktracer.Tracer
+}
+
+func (p *mockTracerProvider) Tracer(name string, options ...trace.TracerOption) trace.Tracer {
+	return p.tracer
+}
+
+func newTracerProvider() *mockTracerProvider {
+	return &mockTracerProvider{
+		mocktracer.NewTracer(instrumentationName),
+	}
+}
+
 type mockConnectObserver struct {
 	callCount int
 }
@@ -108,14 +122,15 @@ func TestQuery(t *testing.T) {
 	controller := getController(t)
 	defer afterEach()
 	cluster := getCluster()
-	tracer := mocktracer.NewTracer("gocql-test")
+	tracerProvider := newTracerProvider()
 
-	ctx, parentSpan := tracer.Start(context.Background(), "gocql-test")
+	ctx, parentSpan := tracerProvider.tracer.Start(context.Background(), "gocql-test")
 
 	session, err := NewSessionWithTracing(
 		ctx,
 		cluster,
-		WithTracer(tracer),
+		WithTracerProvider(tracerProvider),
+		WithMeterProvider(controller.Provider()),
 		WithConnectInstrumentation(false),
 	)
 	require.NoError(t, err)
@@ -132,7 +147,7 @@ func TestQuery(t *testing.T) {
 	parentSpan.End()
 
 	// Get the spans and ensure that they are child spans to the local parent
-	spans := tracer.EndedSpans()
+	spans := tracerProvider.tracer.EndedSpans()
 
 	// Collect all the connection spans
 	// total spans:
@@ -229,14 +244,15 @@ func TestBatch(t *testing.T) {
 	controller := getController(t)
 	defer afterEach()
 	cluster := getCluster()
-	tracer := mocktracer.NewTracer("gocql-test")
+	tracerProvider := newTracerProvider()
 
-	ctx, parentSpan := tracer.Start(context.Background(), "gocql-test")
+	ctx, parentSpan := tracerProvider.tracer.Start(context.Background(), "gocql-test")
 
 	session, err := NewSessionWithTracing(
 		ctx,
 		cluster,
-		WithTracer(tracer),
+		WithTracerProvider(tracerProvider),
+		WithMeterProvider(controller.Provider()),
 		WithConnectInstrumentation(false),
 	)
 	require.NoError(t, err)
@@ -255,7 +271,7 @@ func TestBatch(t *testing.T) {
 
 	parentSpan.End()
 
-	spans := tracer.EndedSpans()
+	spans := tracerProvider.tracer.EndedSpans()
 	// total spans:
 	// 1 span for the query
 	// 1 span for the local span
@@ -326,21 +342,22 @@ func TestConnection(t *testing.T) {
 	controller := getController(t)
 	defer afterEach()
 	cluster := getCluster()
-	tracer := mocktracer.NewTracer("gocql-test")
+	tracerProvider := newTracerProvider()
 	connectObserver := &mockConnectObserver{0}
 	ctx := context.Background()
 
 	session, err := NewSessionWithTracing(
 		ctx,
 		cluster,
-		WithTracer(tracer),
+		WithTracerProvider(tracerProvider),
+		WithMeterProvider(controller.Provider()),
 		WithConnectObserver(connectObserver),
 	)
 	require.NoError(t, err)
 	defer session.Close()
 	require.NoError(t, session.AwaitSchemaAgreement(ctx))
 
-	spans := tracer.EndedSpans()
+	spans := tracerProvider.tracer.EndedSpans()
 
 	assert.Less(t, 0, connectObserver.callCount)
 
@@ -422,7 +439,6 @@ func getCluster() *gocql.ClusterConfig {
 // export pipeline.
 func getController(t *testing.T) *push.Controller {
 	controller := mockExportPipeline(t)
-	InstrumentWithProvider(controller.Provider())
 	return controller
 }