sc := trace.SpanContextFromContext(ctx)
	tid := utils.BinaryFromSpanContext(sc)
	md := metadata.Pairs("grpc-trace-bin", string(tid))
	ctx = metadata.NewOutgoingContext(ctx, md)

package daprtest

import (
	"context"
	"encoding/json"
	"go-api/services/trace"

	dapr "github.com/dapr/go-sdk/client"

	otel "go.opentelemetry.io/otel"
	sdktrace "go.opentelemetry.io/otel/trace"
	"google.golang.org/grpc/metadata"

	"github.com/google/uuid"

	cloudevents "github.com/cloudevents/sdk-go/v2"
)

var daprClient dapr.Client

func DoTheThing() {

	var err error

	daprClient, err = dapr.NewClient()
	if err != nil {
		panic("cannot create dapr client")
	}

	// context would come from some other place, which has instantiated the parent span already
	// otherwise this will be the root span with new trace id
	ctx := context.Background()

	_, span := trace.Tracer.Start(ctx, "lalalal")
	defer span.End()

	data := map[string]string{"something": "happened"}

	publishEvent("topic", ctx, data)
}

func publishEvent(topic string, ctx context.Context, data interface{}) {

	sc := sdktrace.SpanContextFromContext(ctx)
	tid := string(binaryFromSpanContext(sc))

	md := metadata.Pairs("grpc-trace-bin", tid)
	newCtx := metadata.NewOutgoingContext(ctx, md)

	err := daprClient.PublishEvent(
		newCtx, // this new context contains grpc metadata with "grpc-trace-bin"
		"pubsub",
		topic,
		formatRawCloudEvent(topic, ctx, data),
	)

	if err != nil {
		panic(err)
	}
}

// https://github.com/dapr/dapr/blob/release-1.13/pkg/diagnostics/utils/trace_utils.go#L134
func binaryFromSpanContext(sc sdktrace.SpanContext) []byte {
	traceID := sc.TraceID()
	spanID := sc.SpanID()
	traceFlags := sc.TraceFlags()

	var b [29]byte
	copy(b[2:18], traceID[:])
	b[18] = 1
	copy(b[19:27], spanID[:])
	b[27] = 2
	b[28] = uint8(traceFlags)

	return b[:]
}

func formatRawCloudEvent(topic string, ctx context.Context, data interface{}) string {
	event := cloudevents.NewEvent()
	event.SetID(uuid.NewString())
	event.SetSource("test-source")
	event.SetType(topic)

	carrier := CloudEventCarrier{Event: &event}

	event.SetData("application/json", data)

	otel.GetTextMapPropagator().Inject(ctx, carrier)

	j, err := json.Marshal(event)
	if err != nil {
		panic(err)
	}

	return string(j)
}

/** cloud event carrier for otel */

type CloudEventCarrier struct {
	Event *cloudevents.Event
}

// Get returns the value associated with the passed key.
func (c CloudEventCarrier) Get(key string) string {
	ext, err := c.Event.Context.GetExtension(key)
	if err != nil {
		return ""
	}

	return ext.(string)
}

// Set stores the key-value pair.
func (c CloudEventCarrier) Set(key, value string) {
	c.Event.Context.SetExtension(key, value)
}

// Keys lists the keys stored in this carrier.
func (c CloudEventCarrier) Keys() []string {
	ext := c.Event.Context.GetExtensions()

	keys := make([]string, 0, len(ext))
	for k := range ext {
		keys = append(keys, k)
	}

	return keys
}