some working stuff

Author: grambbledook

cmd/go-cache-plugin/commands.go

@@ -10,13 +10,11 @@ import (
 	"errors"
 	"fmt"
 	"github.com/grafana/go-cache-plugin/lib/otel"
-	"github.com/grafana/go-cache-plugin/lib/toolexec"
 	"io"
 	"log"
 	"net"
 	"net/http"
 	"os"
-	"os/exec"
 	"os/signal"
 	"strconv"
 	"strings"
@@ -35,7 +33,7 @@ var flags struct {
 	S3Region             string        `flag:"region,default=$GOCACHE_S3_REGION,S3 region"`
 	S3Endpoint           string        `flag:"s3-endpoint-url,default=$GOCACHE_S3_ENDPOINT_URL,S3 custom endpoint URL (if unset, use AWS default)"`
 	S3PathStyle          bool          `flag:"s3-path-style,default=$GOCACHE_S3_PATH_STYLE,S3 path-style URLs (optional)"`
-	LocalCache           bool          `flag:"local-cache,default=false,Runs in no cache mode (no S3)"`
+	LocalCache           bool          `flag:"local-cache,default=$GOCACHE_LOCAL,Runs in no cache mode (no S3)"`
 	KeyPrefix            string        `flag:"prefix,default=$GOCACHE_KEY_PREFIX,S3 key prefix (optional)"`
 	MinUploadSize        int64         `flag:"min-upload-size,default=$GOCACHE_MIN_SIZE,Minimum object size to upload to S3 (in bytes)"`
 	Concurrency          int           `flag:"c,default=$GOCACHE_CONCURRENCY,Maximum number of concurrent requests"`
@@ -44,9 +42,15 @@ var flags struct {
 	Expiration           time.Duration `flag:"expiry,default=$GOCACHE_EXPIRY,Cache expiration period (optional)"`
 	Verbose              bool          `flag:"v,default=$GOCACHE_VERBOSE,Enable verbose logging"`
 	DebugLog             int           `flag:"debug,default=$GOCACHE_DEBUG,Enable detailed per-request debug logging (noisy)"`
-	TracingEnabled       bool          `flag:"tracing,default=false,Enable tracing (optional)"`
-	TracingContext       string        `flag:"context,default=runId:runAttempt:jobName:stepName:stepNumber,Tracing params"`
-	OtelCollectorAddress string        `flag:"otel-collector,default,OTEL collector address (optional)"`
+	TracingEnabled       bool          `flag:"tracing,default=$ENABLE_TRACING,Enable tracing (optional)"`
+	OtelCollectorAddress string        `flag:"otel-collector,default=$OTEL_COLLECTOR_ADDRESS,OTEL collector address (optional)"`
+	TraceId              string        `flag:"traceId,default=$TRACING_TRACE_ID,Trace Id (optional)"`
+	ParentSpanId         string        `flag:"parentSpanId,default=$TRACING_PARENT_SPAN_ID,Parent Span Id (optional)"`
+	RunId                string        `flag:"runId,default=$RUN_ID,Run ID (optional)"`
+	RunAttempt           string        `flag:"runAttempt,default=$RUN_ATTEMPT,Run attempt (optional)"`
+	JobName              string        `flag:"jobName,default=$JOB_NAME,Job name (optional)"`
+	StepName             string        `flag:"stepName,default=$STEP_NAME,Step name (optional)"`
+	StepNumber           string        `flag:"stepNumber,default=$STEP_NUMBER,Step number (optional)"`
 }
 
 const (
@@ -75,18 +79,11 @@ var serveFlags struct {
 	Plugin     string `flag:"plugin,default=$GOCACHE_PLUGIN,Plugin service addr (or port) (required)"`
 	HTTP       string `flag:"http,default=$GOCACHE_HTTP,HTTP service address ([host]:port)"`
 	ModProxy   bool   `flag:"modproxy,default=$GOCACHE_MODPROXY,Enable a Go module proxy (requires --http)"`
-	ModNoCache bool   `flag:"mod-nocache,default=false,Disable the local module cache (requires --modproxy)"`
+	ModNoCache bool   `flag:"mod-nocache,default=$GOCACHE_MODPROXY_NOCACHE,Disable the local module cache (requires --modproxy)"`
 	RevProxy   string `flag:"revproxy,default=$GOCACHE_REVPROXY,Reverse proxy these hosts (comma-separated; requires --http)"`
 	SumDB      string `flag:"sumdb,default=$GOCACHE_SUMDB,SumDB servers to proxy for (comma-separated)"`
 }
 
-var toolexecFlags struct {
-	LogFile              string `flag:"log-file,default=trace.log,File used for logs"`
-	TracingEnabled       bool   `flag:"tracing,default=false,Enable tracing (optional)"`
-	TracingContext       string `flag:"context,default=runId:runAttempt:jobName:stepName:stepNumber,Tracing params"`
-	OtelCollectorAddress string `flag:"otel-collector,default,OTEL collector address (optional)"`
-}
-
 func noopClose(context.Context) error { return nil }
 
 // runServe runs a cache communicating over a local TCP socket.
@@ -144,7 +141,10 @@ func runServe(env *command.Env) error {
 	// If an HTTP server is enabled, start it up with debug routes
 	// and whatever other services were requested.
 	if serveFlags.HTTP != "" {
-		otelCleanup, tracingContext, err := initModTracing(ctx)
+		otelCleanup, tracingContext, err := initModTracing(ctx, "gobuild-modcache")
+		if err != nil {
+			return fmt.Errorf("tracing: %w", err)
+		}
 		if err != nil {
 			return fmt.Errorf("tracing: %w", err)
 		}
@@ -195,7 +195,7 @@ func runServe(env *command.Env) error {
 func runConnect(env *command.Env, plugin string) error {
 
 	ctx := env.Context()
-	shutdownTracer, reportSpan, err := initTracing(ctx)
+	shutdownTracer, reportSpan, err := initTracing(ctx, "gobuild-gocacheprog-connect")
 	if err != nil {
 		return err
 	}
@@ -228,44 +228,22 @@ func runConnect(env *command.Env, plugin string) error {
 	conn.Close()
 
 	shutdownTracer(context.Background())
-	println("@@@@@ - connection closed @@@@@")
-	println(fmt.Sprintf("connection closed (%v elapsed)", time.Since(start)))
+	vprintf(fmt.Sprintf("connection closed (%v elapsed)", time.Since(start)))
 	return nil
 }
 
-func runToolexec(env *command.Env) error {
-	ctx := env.Context()
-	shutdownTracer, tracingContext, err := initModTracing(ctx)
-	if err != nil {
-		return err
-	}
-	defer shutdownTracer(ctx)
-
-	tool := os.Args[1]
-	args := os.Args[2:]
-
-	pkg := toolexec.GetPackage(os.Args)
-
-	_, span := tracingContext.SpanWithContext(ctx, fmt.Sprintf("%s: %s", toolexec.GetTool(tool), pkg))
-	defer span.End()
-	cmd := exec.Command(tool, args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
-
-func initTracing(ctx context.Context) (func(context.Context) error, func([]byte), error) {
+func initTracing(ctx context.Context, service string) (func(context.Context) error, func([]byte), error) {
 	if !flags.TracingEnabled {
 		return func(context.Context) error { return nil }, func([]byte) {}, nil
 	}
 
 	var shutdown func(context.Context) error
 	var err error
 	if flags.OtelCollectorAddress != "" {
-		shutdown, err = otel.SetupOtelTraceProvider(ctx, flags.OtelCollectorAddress)
+		shutdown, err = otel.SetupOtelTraceProvider(ctx, service, flags.OtelCollectorAddress)
 	} else if flags.LogFile != "" {
 		log.Printf("Otel Collector address not specified, starting with the logging reporter, log file: %s", flags.LogFile)
-		shutdown, err = otel.SetupLoggingProvider(ctx, flags.LogFile)
+		shutdown, err = otel.SetupLoggingProvider(ctx, service, flags.LogFile)
 	} else {
 		log.Printf("please specify either --otel-collector or --log-file to setup tracing or disable tracing")
 		return nil, nil, errors.New("otel exporter not initialized")
@@ -274,42 +252,55 @@ func initTracing(ctx context.Context) (func(context.Context) error, func([]byte)
 		return nil, nil, err
 	}
 
-	tracingContext := otel.NewTracedFromString(flags.TracingContext)
-
+	tracingContext, err := initTracingContext()
+	if err != nil {
+		return nil, nil, err
+	}
 	spanner := otel.NewAwesomeSpanner(tracingContext)
 
 	spanReporter := func(buffer []byte) {
 		id, err := parseId(buffer[:])
 		if err != nil {
-			log.Printf("failed to parse id from buffer: %v", err)
+			return
 		}
 		spanner.ProcessId(ctx, id)
 	}
 
 	return shutdown, spanReporter, err
 }
-func initModTracing(ctx context.Context) (func(context.Context) error, *otel.TracingContext, error) {
+func initModTracing(ctx context.Context, service string) (func(context.Context) error, *otel.TracingContext, error) {
 	if !flags.TracingEnabled {
 		return func(context.Context) error { return nil }, nil, nil
 	}
 
 	var shutdown func(context.Context) error
 	var err error
 	if flags.OtelCollectorAddress != "" {
-		shutdown, err = otel.SetupOtelTraceProvider(ctx, flags.OtelCollectorAddress)
+		shutdown, err = otel.SetupOtelTraceProvider(ctx, service, flags.OtelCollectorAddress)
 	} else if flags.LogFile != "" {
 		log.Printf("Otel Collector address not specified, starting with the logging reporter, log file: %s", flags.LogFile)
-		shutdown, err = otel.SetupLoggingProvider(ctx, flags.LogFile)
+		shutdown, err = otel.SetupLoggingProvider(ctx, service, flags.LogFile)
 	} else {
 		log.Printf("please specify either --otel-collector or --log-file to setup tracing or disable tracing")
 		return nil, nil, errors.New("otel exporter not initialized")
 	}
 
-	tracingContext := otel.NewTracedFromString(flags.TracingContext)
+	tracingContext, err := initTracingContext()
+	if err != nil {
+		return nil, nil, err
+	}
 
 	return shutdown, tracingContext, err
 }
 
+func initTracingContext() (*otel.TracingContext, error) {
+	if flags.TraceId != "" && flags.ParentSpanId != "" {
+		return otel.NewTracingContext(flags.TraceId, flags.ParentSpanId)
+	} else {
+		return otel.NewTracingContextFromRunData(flags.RunId, flags.RunAttempt, flags.JobName, flags.StepName, flags.StepNumber), nil
+	}
+}
+
 // copy emulates the base case of io.Copy, but does not attempt to use the
 // io.ReaderFrom or io.WriterTo implementations.
 //
@@ -336,20 +327,61 @@ func copy(w io.Writer, r io.Reader, reportTrace func([]byte)) error {
 	}
 }
 
-func parseId(buf []byte) (string, error) {
-	map1 := make(map[string]any)
+type name struct {
+}
+
+func parseId(buf []byte) (otel.CacheRequest, error) {
+	var data map[string]any
 
-	err := json.Unmarshal(buf, &map1)
+	err := json.Unmarshal(buf, &data)
 	if err != nil {
 		slice, _, found := bytes.Cut(buf, []byte{'\n'})
 		if found {
-			err2 := json.Unmarshal(slice, &map1)
+			err2 := json.Unmarshal(slice, &data)
 			if err2 != nil {
-				return "", err
+				return otel.CacheRequest{}, err
 			}
 		}
 	}
 
-	value := map1["ID"]
-	return fmt.Sprintf("map1 = %v", value), nil
+	var id string
+	var miss bool
+	var command string
+	var actionId string
+
+	id1, ok := data["ID"]
+	if !ok {
+		return otel.CacheRequest{}, errors.New("id not found in the request")
+	} else {
+		id = fmt.Sprint(id1)
+	}
+
+	command1, ok := data["Command"]
+	if !ok {
+		command = ""
+	} else {
+		command = fmt.Sprint(command1)
+	}
+
+	_, ok = data["Miss"]
+	if !ok {
+		miss = false
+	} else {
+		miss = true
+	}
+
+	actionId1, ok := data["ActionID"]
+	if !ok {
+		actionId = ""
+	} else {
+		actionId = fmt.Sprint(actionId1)
+	}
+
+	data2 := otel.CacheRequest{
+		Id:       id,
+		ActionId: actionId,
+		Miss:     miss,
+		Command:  command,
+	}
+	return data2, nil
 }

cmd/go-cache-plugin/go-cache-plugin.go

@@ -74,11 +74,6 @@ This mode bridges stdin/stdout to a cache server (see the "serve" command)
 listening on the specified port.`,
 				Run: command.Adapt(runConnect),
 			},
-			{
-				Name:     "toolexec",
-				SetFlags: command.Flags(flax.MustBind, &toolexecFlags),
-				Run:      command.Adapt(runToolexec),
-			},
 			command.HelpCommand(helpTopics),
 			command.VersionCommand(),
 		},

lib/otel/collectors.go

@@ -3,34 +3,30 @@ package otel
 import (
 	"context"
 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
 	"go.opentelemetry.io/otel/sdk/resource"
 	"go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
 	"log"
 	"os"
 )
 
 var tp *trace.TracerProvider
 
-func SetupLoggingProvider(ctx context.Context, file string) (func(context.Context) error, error) {
+func SetupLoggingProvider(ctx context.Context, service, file string) (func(context.Context) error, error) {
 	f, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
 	if err != nil {
 		log.Fatalf("error opening file: %v", err)
 	}
 	exporter, err := stdouttrace.New(stdouttrace.WithWriter(f))
 
-	tp = trace.NewTracerProvider(
-		trace.WithBatcher(exporter),
-		trace.WithResource(resource.Default()),
-	)
-
-	otel.SetTracerProvider(tp)
-
-	return tp.Shutdown, nil
+	shutdownHook := setupTraceProvider(service, exporter)
+	return shutdownHook, nil
 }
 
-func SetupOtelTraceProvider(ctx context.Context, address string) (func(context.Context) error, error) {
+func SetupOtelTraceProvider(ctx context.Context, service, address string) (func(context.Context) error, error) {
 	exporter, err := otlptracegrpc.New(ctx,
 		otlptracegrpc.WithEndpoint(address),
 		otlptracegrpc.WithInsecure(),
@@ -40,12 +36,24 @@ func SetupOtelTraceProvider(ctx context.Context, address string) (func(context.C
 		return nil, err
 	}
 
+	shutdownHook := setupTraceProvider(service, exporter)
+
+	return shutdownHook, nil
+}
+
+func setupTraceProvider(service string, exporter trace.SpanExporter) func(ctx context.Context) error {
+
+	res := resource.NewWithAttributes(
+		semconv.SchemaURL,
+		semconv.ServiceName(service),
+		attribute.String("env", "ci"),
+	)
+
 	tp = trace.NewTracerProvider(
 		trace.WithBatcher(exporter),
-		trace.WithResource(resource.Default()),
+		trace.WithResource(res),
 	)
 
 	otel.SetTracerProvider(tp)
-
-	return tp.Shutdown, nil
+	return tp.Shutdown
 }