func configureFromProviderConfig()

in pilot/pkg/networking/core/v1alpha3/tracing.go [133:262]
119 lines of code
15 McCabe index (conditional complexity)

func configureFromProviderConfig(pushCtx *model.PushContext, meta *model.NodeMetadata,
	providerCfg *meshconfig.MeshConfig_ExtensionProvider) (*hpb.HttpConnectionManager_Tracing, *xdsfilters.RouterFilterContext, error) {
	tracing := &hpb.HttpConnectionManager_Tracing{}
	var rfCtx *xdsfilters.RouterFilterContext
	var err error

	switch provider := providerCfg.Provider.(type) {
	case *meshconfig.MeshConfig_ExtensionProvider_Zipkin:
		tracing, err = buildHCMTracing(pushCtx, providerCfg.Name, provider.Zipkin.Service, provider.Zipkin.Port, provider.Zipkin.MaxTagLength, zipkinConfigGen)
	case *meshconfig.MeshConfig_ExtensionProvider_Datadog:
		tracing, err = buildHCMTracing(pushCtx, providerCfg.Name, provider.Datadog.Service, provider.Datadog.Port, provider.Datadog.MaxTagLength, datadogConfigGen)
	case *meshconfig.MeshConfig_ExtensionProvider_Lightstep:
		tracing, err = buildHCMTracing(pushCtx, providerCfg.Name, provider.Lightstep.Service, provider.Lightstep.Port, provider.Lightstep.MaxTagLength,
			func(hostname, clusterName string) (*anypb.Any, error) {
				lc := &tracingcfg.LightstepConfig{
					CollectorCluster: clusterName,
					AccessTokenFile:  provider.Lightstep.AccessToken,
				}
				return anypb.New(lc)
			})

	case *meshconfig.MeshConfig_ExtensionProvider_Opencensus:
		tracing, err = buildHCMTracingOpenCensus(providerCfg.Name, provider.Opencensus.MaxTagLength, func() (*anypb.Any, error) {
			oc := &tracingcfg.OpenCensusConfig{
				OcagentAddress:         fmt.Sprintf("%s:%d", provider.Opencensus.Service, provider.Opencensus.Port),
				OcagentExporterEnabled: true,
				IncomingTraceContext:   convert(provider.Opencensus.Context),
				OutgoingTraceContext:   convert(provider.Opencensus.Context),
			}

			return anypb.New(oc)
		})

	case *meshconfig.MeshConfig_ExtensionProvider_Skywalking:
		tracing, err = buildHCMTracing(pushCtx, providerCfg.Name, provider.Skywalking.Service,
			provider.Skywalking.Port, 0, func(hostname, clusterName string) (*anypb.Any, error) {
				s := &tracingcfg.SkyWalkingConfig{
					GrpcService: &envoy_config_core_v3.GrpcService{
						TargetSpecifier: &envoy_config_core_v3.GrpcService_EnvoyGrpc_{
							EnvoyGrpc: &envoy_config_core_v3.GrpcService_EnvoyGrpc{
								ClusterName: clusterName,
								Authority:   hostname,
							},
						},
					},
				}

				return anypb.New(s)
			})

		rfCtx = &xdsfilters.RouterFilterContext{
			StartChildSpan: true,
		}

	case *meshconfig.MeshConfig_ExtensionProvider_Stackdriver:
		tracing, err = buildHCMTracingOpenCensus(providerCfg.Name, provider.Stackdriver.MaxTagLength, func() (*anypb.Any, error) {
			proj, ok := meta.PlatformMetadata[platform.GCPProject]
			if !ok {
				proj, ok = meta.PlatformMetadata[platform.GCPProjectNumber]
			}
			if !ok {
				return nil, fmt.Errorf("could not configure Stackdriver tracer - unknown project id")
			}

			sd := &tracingcfg.OpenCensusConfig{
				StackdriverExporterEnabled: true,
				StackdriverProjectId:       proj,
				IncomingTraceContext:       allContexts,
				OutgoingTraceContext:       allContexts,
				StdoutExporterEnabled:      provider.Stackdriver.Debug,
				TraceConfig: &opb.TraceConfig{
					MaxNumberOfAnnotations:   200,
					MaxNumberOfAttributes:    200,
					MaxNumberOfMessageEvents: 200,
				},
			}

			if meta.StsPort != "" {
				stsPort, err := strconv.Atoi(meta.StsPort)
				if err != nil || stsPort < 1 {
					return nil, fmt.Errorf("could not configure Stackdriver tracer - bad sts port: %v", err)
				}
				sd.StackdriverGrpcService = &envoy_config_core_v3.GrpcService{
					InitialMetadata: []*envoy_config_core_v3.HeaderValue{
						{
							Key:   "x-goog-user-project",
							Value: proj,
						},
					},
					TargetSpecifier: &envoy_config_core_v3.GrpcService_GoogleGrpc_{
						GoogleGrpc: &envoy_config_core_v3.GrpcService_GoogleGrpc{
							TargetUri:  "cloudtrace.googleapis.com",
							StatPrefix: "oc_stackdriver_tracer",
							ChannelCredentials: &envoy_config_core_v3.GrpcService_GoogleGrpc_ChannelCredentials{
								CredentialSpecifier: &envoy_config_core_v3.GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials{
									SslCredentials: &envoy_config_core_v3.GrpcService_GoogleGrpc_SslCredentials{},
								},
							},
							CallCredentials: []*envoy_config_core_v3.GrpcService_GoogleGrpc_CallCredentials{
								{
									CredentialSpecifier: &envoy_config_core_v3.GrpcService_GoogleGrpc_CallCredentials_StsService_{
										StsService: &envoy_config_core_v3.GrpcService_GoogleGrpc_CallCredentials_StsService{
											TokenExchangeServiceUri: fmt.Sprintf("http://localhost:%d/token", stsPort),
											SubjectTokenPath:        constants.TrustworthyJWTPath,
											SubjectTokenType:        "urn:ietf:params:oauth:token-type:jwt",
											Scope:                   "https://www.googleapis.com/auth/cloud-platform",
										},
									},
								},
							},
						},
					},
				}
			}

			if provider.Stackdriver.MaxNumberOfAnnotations != nil {
				sd.TraceConfig.MaxNumberOfAnnotations = provider.Stackdriver.MaxNumberOfAnnotations.Value
			}
			if provider.Stackdriver.MaxNumberOfAttributes != nil {
				sd.TraceConfig.MaxNumberOfAttributes = provider.Stackdriver.MaxNumberOfAttributes.Value
			}
			if provider.Stackdriver.MaxNumberOfMessageEvents != nil {
				sd.TraceConfig.MaxNumberOfMessageEvents = provider.Stackdriver.MaxNumberOfMessageEvents.Value
			}
			return anypb.New(sd)
		})
	}

	return tracing, rfCtx, err
}