From 8301a7e7a3de806dfc9be4c696e927a87ee66dc2 Mon Sep 17 00:00:00 2001 From: "A.Unger" Date: Fri, 6 Aug 2021 13:46:54 +0200 Subject: [PATCH] propagate trace from ocs to proxy --- ocs/pkg/service/v0/users.go | 11 ++-- ocs/pkg/tracing/tracing.go | 109 +++++++++++++----------------------- proxy/pkg/proxy/proxy.go | 3 + 3 files changed, 50 insertions(+), 73 deletions(-) diff --git a/ocs/pkg/service/v0/users.go b/ocs/pkg/service/v0/users.go index 28b0d0b40f..4f86f7dd59 100644 --- a/ocs/pkg/service/v0/users.go +++ b/ocs/pkg/service/v0/users.go @@ -9,14 +9,13 @@ import ( "strconv" "strings" - "github.com/cs3org/reva/pkg/auth/scope" - "github.com/asim/go-micro/plugins/client/grpc/v3" merrors "github.com/asim/go-micro/v3/errors" gateway "github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1" revauser "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1" rpcv1beta1 "github.com/cs3org/go-cs3apis/cs3/rpc/v1beta1" provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1" + "github.com/cs3org/reva/pkg/auth/scope" "github.com/cs3org/reva/pkg/rgrpc/todo/pool" "github.com/cs3org/reva/pkg/token" "github.com/cs3org/reva/pkg/token/manager/jwt" @@ -26,6 +25,7 @@ import ( accounts "github.com/owncloud/ocis/accounts/pkg/proto/v0" "github.com/owncloud/ocis/ocs/pkg/service/v0/data" "github.com/owncloud/ocis/ocs/pkg/service/v0/response" + ocstracing "github.com/owncloud/ocis/ocs/pkg/tracing" storepb "github.com/owncloud/ocis/store/pkg/proto/v0" "github.com/pkg/errors" "google.golang.org/genproto/protobuf/field_mask" @@ -91,13 +91,16 @@ func (o Ocs) GetUser(w http.ResponseWriter, r *http.Request) { var account *accounts.Account var err error + ctx, span := ocstracing.TraceProvider.Tracer("ocs").Start(r.Context(), "GetUser") + defer span.End() + switch { case userid == "": mustNotFail(render.Render(w, r, response.ErrRender(data.MetaBadRequest.StatusCode, "missing user in context"))) case o.config.AccountBackend == "accounts": - account, err = o.fetchAccountByUsername(r.Context(), userid) + account, err = o.fetchAccountByUsername(ctx, userid) case o.config.AccountBackend == "cs3": - account, err = o.fetchAccountFromCS3Backend(r.Context(), userid) + account, err = o.fetchAccountFromCS3Backend(ctx, userid) default: o.logger.Fatal().Msgf("Invalid accounts backend type '%s'", o.config.AccountBackend) } diff --git a/ocs/pkg/tracing/tracing.go b/ocs/pkg/tracing/tracing.go index b79bb7e61c..9b8f94a1fd 100644 --- a/ocs/pkg/tracing/tracing.go +++ b/ocs/pkg/tracing/tracing.go @@ -1,87 +1,58 @@ package tracing import ( - "time" - - "contrib.go.opencensus.io/exporter/jaeger" - "contrib.go.opencensus.io/exporter/ocagent" - "contrib.go.opencensus.io/exporter/zipkin" - openzipkin "github.com/openzipkin/zipkin-go" - zipkinhttp "github.com/openzipkin/zipkin-go/reporter/http" "github.com/owncloud/ocis/ocis-pkg/log" "github.com/owncloud/ocis/ocs/pkg/config" - "go.opencensus.io/stats/view" - "go.opencensus.io/trace" + "go.opentelemetry.io/otel/exporters/jaeger" + "go.opentelemetry.io/otel/propagation" + "go.opentelemetry.io/otel/sdk/resource" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + semconv "go.opentelemetry.io/otel/semconv/v1.4.0" +) + +var ( + // Propagator ensures the entire module uses the same trace propagation strategy. + Propagator propagation.TextMapPropagator + + // TraceProvider is the global trace provider for the proxy service. + TraceProvider *sdktrace.TracerProvider ) func Configure(cfg *config.Config, logger log.Logger) error { if cfg.Tracing.Enabled { switch t := cfg.Tracing.Type; t { - case "agent": - exporter, err := ocagent.NewExporter( - ocagent.WithReconnectionPeriod(5*time.Second), - ocagent.WithAddress(cfg.Tracing.Endpoint), - ocagent.WithServiceName(cfg.Tracing.Service), - ) - if err != nil { - logger.Error(). - Err(err). - Str("endpoint", cfg.Tracing.Endpoint). - Str("collector", cfg.Tracing.Collector). - Msg("Failed to create agent tracing") - return err - } - trace.RegisterExporter(exporter) - view.RegisterExporter(exporter) case "jaeger": - exporter, err := jaeger.NewExporter( - jaeger.Options{ - AgentEndpoint: cfg.Tracing.Endpoint, - CollectorEndpoint: cfg.Tracing.Collector, - Process: jaeger.Process{ - ServiceName: cfg.Tracing.Service, - }, - }, - ) - if err != nil { - logger.Error(). - Err(err). - Str("endpoint", cfg.Tracing.Endpoint). - Str("collector", cfg.Tracing.Collector). - Msg("Failed to create jaeger tracing") - return err + { + exp, err := jaeger.New( + jaeger.WithCollectorEndpoint( + jaeger.WithEndpoint(cfg.Tracing.Collector), + ), + ) + if err != nil { + panic(err) + } + + // set package level trace provider and propagator. + TraceProvider = sdktrace.NewTracerProvider( + sdktrace.WithBatcher(exp), + sdktrace.WithResource(resource.NewWithAttributes( + semconv.SchemaURL, + semconv.ServiceNameKey.String("ocs")), + ), + ) + + Propagator = propagation.NewCompositeTextMapPropagator( + propagation.Baggage{}, + propagation.TraceContext{}, + ) } - trace.RegisterExporter(exporter) + case "agent": + fallthrough case "zipkin": - endpoint, err := openzipkin.NewEndpoint( - cfg.Tracing.Service, - cfg.Tracing.Endpoint, - ) - if err != nil { - logger.Error(). - Err(err). - Str("endpoint", cfg.Tracing.Endpoint). - Str("collector", cfg.Tracing.Collector). - Msg("Failed to create zipkin tracing") - return err - } - exporter := zipkin.NewExporter( - zipkinhttp.NewReporter( - cfg.Tracing.Collector, - ), - endpoint, - ) - trace.RegisterExporter(exporter) + fallthrough default: - logger.Warn(). - Str("type", t). - Msg("Unknown tracing backend") + logger.Warn().Str("type", t).Msg("Unknown tracing backend") } - trace.ApplyConfig( - trace.Config{ - DefaultSampler: trace.AlwaysSample(), - }, - ) } else { logger.Debug(). Msg("Tracing is not enabled") diff --git a/proxy/pkg/proxy/proxy.go b/proxy/pkg/proxy/proxy.go index 2430b2b43b..97c6ade90a 100644 --- a/proxy/pkg/proxy/proxy.go +++ b/proxy/pkg/proxy/proxy.go @@ -11,6 +11,8 @@ import ( "strings" "time" + "go.opentelemetry.io/otel/propagation" + "github.com/owncloud/ocis/ocis-pkg/log" "github.com/owncloud/ocis/proxy/pkg/config" "github.com/owncloud/ocis/proxy/pkg/proxy/policy" @@ -222,6 +224,7 @@ func (p *MultiHostReverseProxy) ServeHTTP(w http.ResponseWriter, r *http.Request tracer := proxytracing.TraceProvider.Tracer("proxy") ctx, span = tracer.Start(ctx, fmt.Sprintf("%s %v", r.Method, r.URL.Path)) defer span.End() + proxytracing.Propagator.Inject(ctx, propagation.HeaderCarrier(r.Header)) } p.ReverseProxy.ServeHTTP(w, r.WithContext(ctx)) }