diff --git a/src/internal/events/adot_sdk_client.go b/src/internal/events/adot_sdk_client.go
index 0e45fbbc6..8d08206e3 100644
--- a/src/internal/events/adot_sdk_client.go
+++ b/src/internal/events/adot_sdk_client.go
@@ -2,16 +2,13 @@ package events
 
 import (
 	"context"
-	"fmt"
 	"log"
 	"os"
 	"time"
 
 	"github.com/alcionai/corso/src/pkg/logger"
-	"go.opentelemetry.io/contrib/propagators/aws/xray"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
-	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
 	"google.golang.org/grpc"
 
@@ -19,12 +16,12 @@ import (
 
 	metricSdk "go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/resource"
-	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
+var Ctr metric.Int64Counter
+
 type collector struct {
-	growCounter metric.Int64Counter
-	meter       metric.Meter
+	meter metric.Meter
 }
 
 func Newcollector(mp metric.MeterProvider) collector {
@@ -40,28 +37,19 @@ func (rmc *collector) RegisterMetricsClient(ctx context.Context, cfg Config) {
 	go func() {
 		for {
 			rmc.updateCounter(ctx)
-			time.Sleep(time.Second * 10)
+			time.Sleep(time.Second * 1)
 		}
 	}()
 }
 
 func (rmc *collector) registerCounter() {
-	ctr, err := rmc.meter.Int64Counter(
-		growCounter,
-		metric.WithDescription("counter"),
-		metric.WithUnit("count"),
-	)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	rmc.growCounter = ctr
+	Ctr, _ = rmc.meter.Int64Counter(growCounter)
 }
 
 func (rmc *collector) updateCounter(ctx context.Context) {
 	logger.Ctx(ctx).Infow("updateCounter")
 
-	rmc.growCounter.Add(ctx, 20)
+	Ctr.Add(ctx, 20)
 }
 
 type Config struct {
@@ -69,7 +57,7 @@ type Config struct {
 	Port string
 }
 
-func StartClient(ctx context.Context) (func(context.Context) error, error) {
+func StartClient(ctx context.Context) *metricSdk.MeterProvider {
 	res := resource.NewWithAttributes(
 		semconv.SchemaURL,
 		semconv.ServiceName("corso"),
@@ -77,67 +65,56 @@ func StartClient(ctx context.Context) (func(context.Context) error, error) {
 	if _, present := os.LookupEnv("OTEL_RESOURCE_ATTRIBUTES"); present {
 		envResource, err := resource.New(ctx, resource.WithFromEnv())
 		if err != nil {
-			return nil, err
+			return nil
 		}
 		res = envResource
 	}
 
 	// Setup trace related
-	tp, err := setupTraceProvider(ctx, res)
-	if err != nil {
-		return nil, err
-	}
+	// tp, err := setupTraceProvider(ctx, res)
+	// if err != nil {
+	// 	return nil
+	// }
 
-	otel.SetTracerProvider(tp)
-	otel.SetTextMapPropagator(xray.Propagator{}) // Set AWS X-Ray propagator
+	// otel.SetTracerProvider(tp)
+	// otel.SetTextMapPropagator(xray.Propagator{}) // Set AWS X-Ray propagator
 
 	exp, err := otlpmetricgrpc.New(ctx, otlpmetricgrpc.WithInsecure(), otlpmetricgrpc.WithEndpoint("0.0.0.0:4317"), otlpmetricgrpc.WithDialOption(grpc.WithBlock()))
 	if err != nil {
 		log.Fatalf("failed to create new OTLP metric exporter: %v", err)
 	}
 
-	meterProvider := metricSdk.NewMeterProvider(metricSdk.WithResource(res), metricSdk.WithReader(metricSdk.NewPeriodicReader(exp)))
+	meterProvider := metricSdk.NewMeterProvider(
+		metricSdk.WithReader(metricSdk.NewPeriodicReader(exp)),
+		metricSdk.WithResource(res),
+	)
 
 	otel.SetMeterProvider(meterProvider)
 
-	return func(context.Context) (err error) {
-		ctx, cancel := context.WithTimeout(ctx, time.Second)
-		defer cancel()
-
-		// pushes any last exports to the receiver
-		err = meterProvider.Shutdown(ctx)
-		if err != nil {
-			return err
-		}
-		err = tp.Shutdown(ctx)
-		if err != nil {
-			return err
-		}
-		return nil
-	}, nil
+	return meterProvider
 }
 
-// setupTraceProvider configures a trace exporter and an AWS X-Ray ID Generator.
-func setupTraceProvider(ctx context.Context, res *resource.Resource) (*sdktrace.TracerProvider, error) {
-	// INSECURE !! NOT TO BE USED FOR ANYTHING IN PRODUCTION
-	// traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithInsecure())
-	// Create and start new OTLP trace exporter
-	traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithInsecure(), otlptracegrpc.WithEndpoint("0.0.0.0:4317"), otlptracegrpc.WithDialOption(grpc.WithBlock()))
-	if err != nil {
-		log.Fatalf("failed to create new OTLP trace exporter: %v", err)
-	}
+// // setupTraceProvider configures a trace exporter and an AWS X-Ray ID Generator.
+// func setupTraceProvider(ctx context.Context, res *resource.Resource) (*sdktrace.TracerProvider, error) {
+// 	// INSECURE !! NOT TO BE USED FOR ANYTHING IN PRODUCTION
+// 	// traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithInsecure())
+// 	// Create and start new OTLP trace exporter
+// 	traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithInsecure(), otlptracegrpc.WithEndpoint("0.0.0.0:4317"), otlptracegrpc.WithDialOption(grpc.WithBlock()))
+// 	if err != nil {
+// 		log.Fatalf("failed to create new OTLP trace exporter: %v", err)
+// 	}
 
-	if err != nil {
-		return nil, err
-	}
+// 	if err != nil {
+// 		return nil, err
+// 	}
 
-	idg := xray.NewIDGenerator()
+// 	idg := xray.NewIDGenerator()
 
-	tp := sdktrace.NewTracerProvider(
-		sdktrace.WithSampler(sdktrace.AlwaysSample()),
-		sdktrace.WithBatcher(traceExporter),
-		sdktrace.WithResource(res),
-		sdktrace.WithIDGenerator(idg),
-	)
-	return tp, nil
-}
+// 	tp := sdktrace.NewTracerProvider(
+// 		sdktrace.WithSampler(sdktrace.AlwaysSample()),
+// 		sdktrace.WithBatcher(traceExporter),
+// 		sdktrace.WithResource(res),
+// 		sdktrace.WithIDGenerator(idg),
+// 	)
+// 	return tp, nil
+// }
diff --git a/src/internal/events/events.go b/src/internal/events/events.go
index 3170cd4a1..3f3509444 100644
--- a/src/internal/events/events.go
+++ b/src/internal/events/events.go
@@ -13,7 +13,6 @@ import (
 	"github.com/alcionai/clues"
 	"github.com/armon/go-metrics"
 	analytics "github.com/rudderlabs/analytics-go"
-	"go.opentelemetry.io/otel"
 
 	"github.com/alcionai/corso/src/internal/version"
 	"github.com/alcionai/corso/src/pkg/control"
@@ -212,13 +211,9 @@ const (
 )
 
 func NewMetrics(ctx context.Context, w io.Writer) (context.Context, func()) {
-	_, err := StartClient(ctx)
-	if err != nil {
-		logger.CtxErr(ctx, err).Error("metrics bus constructor")
-		return ctx, func() {}
-	}
+	mp := StartClient(ctx)
 
-	mp := otel.GetMeterProvider()
+	//mpx := otel.GetMeterProvider()
 	rmc := Newcollector(mp)
 	rmc.RegisterMetricsClient(ctx, Config{})