api_client.go - src - Go monorepo.

api_client.go (35184B)
      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package sts
      4 
      5 import (
      6 	"context"
      7 	"errors"
      8 	"fmt"
      9 	"github.com/aws/aws-sdk-go-v2/aws"
     10 	"github.com/aws/aws-sdk-go-v2/aws/defaults"
     11 	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
     12 	"github.com/aws/aws-sdk-go-v2/aws/protocol/query"
     13 	"github.com/aws/aws-sdk-go-v2/aws/retry"
     14 	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
     15 	awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
     16 	internalauth "github.com/aws/aws-sdk-go-v2/internal/auth"
     17 	internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy"
     18 	internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
     19 	internalmiddleware "github.com/aws/aws-sdk-go-v2/internal/middleware"
     20 	acceptencodingcust "github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding"
     21 	presignedurlcust "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url"
     22 	smithy "github.com/aws/smithy-go"
     23 	smithyauth "github.com/aws/smithy-go/auth"
     24 	smithydocument "github.com/aws/smithy-go/document"
     25 	"github.com/aws/smithy-go/logging"
     26 	"github.com/aws/smithy-go/metrics"
     27 	"github.com/aws/smithy-go/middleware"
     28 	"github.com/aws/smithy-go/tracing"
     29 	smithyhttp "github.com/aws/smithy-go/transport/http"
     30 	"net"
     31 	"net/http"
     32 	"sync/atomic"
     33 	"time"
     34 )
     35 
     36 const ServiceID = "STS"
     37 const ServiceAPIVersion = "2011-06-15"
     38 
     39 type operationMetrics struct {
     40 	Duration                metrics.Float64Histogram
     41 	SerializeDuration       metrics.Float64Histogram
     42 	ResolveIdentityDuration metrics.Float64Histogram
     43 	ResolveEndpointDuration metrics.Float64Histogram
     44 	SignRequestDuration     metrics.Float64Histogram
     45 	DeserializeDuration     metrics.Float64Histogram
     46 }
     47 
     48 func (m *operationMetrics) histogramFor(name string) metrics.Float64Histogram {
     49 	switch name {
     50 	case "client.call.duration":
     51 		return m.Duration
     52 	case "client.call.serialization_duration":
     53 		return m.SerializeDuration
     54 	case "client.call.resolve_identity_duration":
     55 		return m.ResolveIdentityDuration
     56 	case "client.call.resolve_endpoint_duration":
     57 		return m.ResolveEndpointDuration
     58 	case "client.call.signing_duration":
     59 		return m.SignRequestDuration
     60 	case "client.call.deserialization_duration":
     61 		return m.DeserializeDuration
     62 	default:
     63 		panic("unrecognized operation metric")
     64 	}
     65 }
     66 
     67 func timeOperationMetric[T any](
     68 	ctx context.Context, metric string, fn func() (T, error),
     69 	opts ...metrics.RecordMetricOption,
     70 ) (T, error) {
     71 	instr := getOperationMetrics(ctx).histogramFor(metric)
     72 	opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
     73 
     74 	start := time.Now()
     75 	v, err := fn()
     76 	end := time.Now()
     77 
     78 	elapsed := end.Sub(start)
     79 	instr.Record(ctx, float64(elapsed)/1e9, opts...)
     80 	return v, err
     81 }
     82 
     83 func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() {
     84 	instr := getOperationMetrics(ctx).histogramFor(metric)
     85 	opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...)
     86 
     87 	var ended bool
     88 	start := time.Now()
     89 	return func() {
     90 		if ended {
     91 			return
     92 		}
     93 		ended = true
     94 
     95 		end := time.Now()
     96 
     97 		elapsed := end.Sub(start)
     98 		instr.Record(ctx, float64(elapsed)/1e9, opts...)
     99 	}
    100 }
    101 
    102 func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption {
    103 	return func(o *metrics.RecordMetricOptions) {
    104 		o.Properties.Set("rpc.service", middleware.GetServiceID(ctx))
    105 		o.Properties.Set("rpc.method", middleware.GetOperationName(ctx))
    106 	}
    107 }
    108 
    109 type operationMetricsKey struct{}
    110 
    111 func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) {
    112 	meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
    113 	om := &operationMetrics{}
    114 
    115 	var err error
    116 
    117 	om.Duration, err = operationMetricTimer(meter, "client.call.duration",
    118 		"Overall call duration (including retries and time to send or receive request and response body)")
    119 	if err != nil {
    120 		return nil, err
    121 	}
    122 	om.SerializeDuration, err = operationMetricTimer(meter, "client.call.serialization_duration",
    123 		"The time it takes to serialize a message body")
    124 	if err != nil {
    125 		return nil, err
    126 	}
    127 	om.ResolveIdentityDuration, err = operationMetricTimer(meter, "client.call.auth.resolve_identity_duration",
    128 		"The time taken to acquire an identity (AWS credentials, bearer token, etc) from an Identity Provider")
    129 	if err != nil {
    130 		return nil, err
    131 	}
    132 	om.ResolveEndpointDuration, err = operationMetricTimer(meter, "client.call.resolve_endpoint_duration",
    133 		"The time it takes to resolve an endpoint (endpoint resolver, not DNS) for the request")
    134 	if err != nil {
    135 		return nil, err
    136 	}
    137 	om.SignRequestDuration, err = operationMetricTimer(meter, "client.call.auth.signing_duration",
    138 		"The time it takes to sign a request")
    139 	if err != nil {
    140 		return nil, err
    141 	}
    142 	om.DeserializeDuration, err = operationMetricTimer(meter, "client.call.deserialization_duration",
    143 		"The time it takes to deserialize a message body")
    144 	if err != nil {
    145 		return nil, err
    146 	}
    147 
    148 	return context.WithValue(parent, operationMetricsKey{}, om), nil
    149 }
    150 
    151 func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Histogram, error) {
    152 	return m.Float64Histogram(name, func(o *metrics.InstrumentOptions) {
    153 		o.UnitLabel = "s"
    154 		o.Description = desc
    155 	})
    156 }
    157 
    158 func getOperationMetrics(ctx context.Context) *operationMetrics {
    159 	return ctx.Value(operationMetricsKey{}).(*operationMetrics)
    160 }
    161 
    162 func operationTracer(p tracing.TracerProvider) tracing.Tracer {
    163 	return p.Tracer("github.com/aws/aws-sdk-go-v2/service/sts")
    164 }
    165 
    166 // Client provides the API client to make operations call for AWS Security Token
    167 // Service.
    168 type Client struct {
    169 	options Options
    170 
    171 	// Difference between the time reported by the server and the client
    172 	timeOffset *atomic.Int64
    173 }
    174 
    175 // New returns an initialized Client based on the functional options. Provide
    176 // additional functional options to further configure the behavior of the client,
    177 // such as changing the client's endpoint or adding custom middleware behavior.
    178 func New(options Options, optFns ...func(*Options)) *Client {
    179 	options = options.Copy()
    180 
    181 	resolveDefaultLogger(&options)
    182 
    183 	setResolvedDefaultsMode(&options)
    184 
    185 	resolveRetryer(&options)
    186 
    187 	resolveHTTPClient(&options)
    188 
    189 	resolveHTTPSignerV4(&options)
    190 
    191 	resolveEndpointResolverV2(&options)
    192 
    193 	resolveTracerProvider(&options)
    194 
    195 	resolveMeterProvider(&options)
    196 
    197 	resolveAuthSchemeResolver(&options)
    198 
    199 	for _, fn := range optFns {
    200 		fn(&options)
    201 	}
    202 
    203 	finalizeRetryMaxAttempts(&options)
    204 
    205 	ignoreAnonymousAuth(&options)
    206 
    207 	wrapWithAnonymousAuth(&options)
    208 
    209 	resolveAuthSchemes(&options)
    210 
    211 	client := &Client{
    212 		options: options,
    213 	}
    214 
    215 	initializeTimeOffsetResolver(client)
    216 
    217 	return client
    218 }
    219 
    220 // Options returns a copy of the client configuration.
    221 //
    222 // Callers SHOULD NOT perform mutations on any inner structures within client
    223 // config. Config overrides should instead be made on a per-operation basis through
    224 // functional options.
    225 func (c *Client) Options() Options {
    226 	return c.options.Copy()
    227 }
    228 
    229 func (c *Client) invokeOperation(
    230 	ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error,
    231 ) (
    232 	result interface{}, metadata middleware.Metadata, err error,
    233 ) {
    234 	ctx = middleware.ClearStackValues(ctx)
    235 	ctx = middleware.WithServiceID(ctx, ServiceID)
    236 	ctx = middleware.WithOperationName(ctx, opID)
    237 
    238 	stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
    239 	options := c.options.Copy()
    240 
    241 	for _, fn := range optFns {
    242 		fn(&options)
    243 	}
    244 
    245 	finalizeOperationRetryMaxAttempts(&options, *c)
    246 
    247 	finalizeClientEndpointResolverOptions(&options)
    248 
    249 	for _, fn := range stackFns {
    250 		if err := fn(stack, options); err != nil {
    251 			return nil, metadata, err
    252 		}
    253 	}
    254 
    255 	for _, fn := range options.APIOptions {
    256 		if err := fn(stack); err != nil {
    257 			return nil, metadata, err
    258 		}
    259 	}
    260 
    261 	ctx, err = withOperationMetrics(ctx, options.MeterProvider)
    262 	if err != nil {
    263 		return nil, metadata, err
    264 	}
    265 
    266 	tracer := operationTracer(options.TracerProvider)
    267 	spanName := fmt.Sprintf("%s.%s", ServiceID, opID)
    268 
    269 	ctx = tracing.WithOperationTracer(ctx, tracer)
    270 
    271 	ctx, span := tracer.StartSpan(ctx, spanName, func(o *tracing.SpanOptions) {
    272 		o.Kind = tracing.SpanKindClient
    273 		o.Properties.Set("rpc.system", "aws-api")
    274 		o.Properties.Set("rpc.method", opID)
    275 		o.Properties.Set("rpc.service", ServiceID)
    276 	})
    277 	endTimer := startMetricTimer(ctx, "client.call.duration")
    278 	defer endTimer()
    279 	defer span.End()
    280 
    281 	handler := smithyhttp.NewClientHandlerWithOptions(options.HTTPClient, func(o *smithyhttp.ClientHandler) {
    282 		o.Meter = options.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
    283 	})
    284 	decorated := middleware.DecorateHandler(handler, stack)
    285 	result, metadata, err = decorated.Handle(ctx, params)
    286 	if err != nil {
    287 		span.SetProperty("exception.type", fmt.Sprintf("%T", err))
    288 		span.SetProperty("exception.message", err.Error())
    289 
    290 		var aerr smithy.APIError
    291 		if errors.As(err, &aerr) {
    292 			span.SetProperty("api.error_code", aerr.ErrorCode())
    293 			span.SetProperty("api.error_message", aerr.ErrorMessage())
    294 			span.SetProperty("api.error_fault", aerr.ErrorFault().String())
    295 		}
    296 
    297 		err = &smithy.OperationError{
    298 			ServiceID:     ServiceID,
    299 			OperationName: opID,
    300 			Err:           err,
    301 		}
    302 	}
    303 
    304 	span.SetProperty("error", err != nil)
    305 	if err == nil {
    306 		span.SetStatus(tracing.SpanStatusOK)
    307 	} else {
    308 		span.SetStatus(tracing.SpanStatusError)
    309 	}
    310 
    311 	return result, metadata, err
    312 }
    313 
    314 type operationInputKey struct{}
    315 
    316 func setOperationInput(ctx context.Context, input interface{}) context.Context {
    317 	return middleware.WithStackValue(ctx, operationInputKey{}, input)
    318 }
    319 
    320 func getOperationInput(ctx context.Context) interface{} {
    321 	return middleware.GetStackValue(ctx, operationInputKey{})
    322 }
    323 
    324 type setOperationInputMiddleware struct {
    325 }
    326 
    327 func (*setOperationInputMiddleware) ID() string {
    328 	return "setOperationInput"
    329 }
    330 
    331 func (m *setOperationInputMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    332 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    333 ) {
    334 	ctx = setOperationInput(ctx, in.Parameters)
    335 	return next.HandleSerialize(ctx, in)
    336 }
    337 
    338 func addProtocolFinalizerMiddlewares(stack *middleware.Stack, options Options, operation string) error {
    339 	if err := stack.Finalize.Add(&resolveAuthSchemeMiddleware{operation: operation, options: options}, middleware.Before); err != nil {
    340 		return fmt.Errorf("add ResolveAuthScheme: %w", err)
    341 	}
    342 	if err := stack.Finalize.Insert(&getIdentityMiddleware{options: options}, "ResolveAuthScheme", middleware.After); err != nil {
    343 		return fmt.Errorf("add GetIdentity: %v", err)
    344 	}
    345 	if err := stack.Finalize.Insert(&resolveEndpointV2Middleware{options: options}, "GetIdentity", middleware.After); err != nil {
    346 		return fmt.Errorf("add ResolveEndpointV2: %v", err)
    347 	}
    348 	if err := stack.Finalize.Insert(&signRequestMiddleware{options: options}, "ResolveEndpointV2", middleware.After); err != nil {
    349 		return fmt.Errorf("add Signing: %w", err)
    350 	}
    351 	return nil
    352 }
    353 func resolveAuthSchemeResolver(options *Options) {
    354 	if options.AuthSchemeResolver == nil {
    355 		options.AuthSchemeResolver = &defaultAuthSchemeResolver{}
    356 	}
    357 }
    358 
    359 func resolveAuthSchemes(options *Options) {
    360 	if options.AuthSchemes == nil {
    361 		options.AuthSchemes = []smithyhttp.AuthScheme{
    362 			internalauth.NewHTTPAuthScheme("aws.auth#sigv4", &internalauthsmithy.V4SignerAdapter{
    363 				Signer:     options.HTTPSignerV4,
    364 				Logger:     options.Logger,
    365 				LogSigning: options.ClientLogMode.IsSigning(),
    366 			}),
    367 		}
    368 	}
    369 }
    370 
    371 type noSmithyDocumentSerde = smithydocument.NoSerde
    372 
    373 type legacyEndpointContextSetter struct {
    374 	LegacyResolver EndpointResolver
    375 }
    376 
    377 func (*legacyEndpointContextSetter) ID() string {
    378 	return "legacyEndpointContextSetter"
    379 }
    380 
    381 func (m *legacyEndpointContextSetter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    382 	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
    383 ) {
    384 	if m.LegacyResolver != nil {
    385 		ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true)
    386 	}
    387 
    388 	return next.HandleInitialize(ctx, in)
    389 
    390 }
    391 func addlegacyEndpointContextSetter(stack *middleware.Stack, o Options) error {
    392 	return stack.Initialize.Add(&legacyEndpointContextSetter{
    393 		LegacyResolver: o.EndpointResolver,
    394 	}, middleware.Before)
    395 }
    396 
    397 func resolveDefaultLogger(o *Options) {
    398 	if o.Logger != nil {
    399 		return
    400 	}
    401 	o.Logger = logging.Nop{}
    402 }
    403 
    404 func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
    405 	return middleware.AddSetLoggerMiddleware(stack, o.Logger)
    406 }
    407 
    408 func setResolvedDefaultsMode(o *Options) {
    409 	if len(o.resolvedDefaultsMode) > 0 {
    410 		return
    411 	}
    412 
    413 	var mode aws.DefaultsMode
    414 	mode.SetFromString(string(o.DefaultsMode))
    415 
    416 	if mode == aws.DefaultsModeAuto {
    417 		mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
    418 	}
    419 
    420 	o.resolvedDefaultsMode = mode
    421 }
    422 
    423 // NewFromConfig returns a new client from the provided config.
    424 func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
    425 	opts := Options{
    426 		Region:               cfg.Region,
    427 		DefaultsMode:         cfg.DefaultsMode,
    428 		RuntimeEnvironment:   cfg.RuntimeEnvironment,
    429 		HTTPClient:           cfg.HTTPClient,
    430 		Credentials:          cfg.Credentials,
    431 		APIOptions:           cfg.APIOptions,
    432 		Logger:               cfg.Logger,
    433 		ClientLogMode:        cfg.ClientLogMode,
    434 		AppID:                cfg.AppID,
    435 		AuthSchemePreference: cfg.AuthSchemePreference,
    436 	}
    437 	resolveAWSRetryerProvider(cfg, &opts)
    438 	resolveAWSRetryMaxAttempts(cfg, &opts)
    439 	resolveAWSRetryMode(cfg, &opts)
    440 	resolveAWSEndpointResolver(cfg, &opts)
    441 	resolveInterceptors(cfg, &opts)
    442 	resolveUseDualStackEndpoint(cfg, &opts)
    443 	resolveUseFIPSEndpoint(cfg, &opts)
    444 	resolveBaseEndpoint(cfg, &opts)
    445 	return New(opts, func(o *Options) {
    446 		for _, opt := range cfg.ServiceOptions {
    447 			opt(ServiceID, o)
    448 		}
    449 		for _, opt := range optFns {
    450 			opt(o)
    451 		}
    452 	})
    453 }
    454 
    455 func resolveHTTPClient(o *Options) {
    456 	var buildable *awshttp.BuildableClient
    457 
    458 	if o.HTTPClient != nil {
    459 		var ok bool
    460 		buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
    461 		if !ok {
    462 			return
    463 		}
    464 	} else {
    465 		buildable = awshttp.NewBuildableClient()
    466 	}
    467 
    468 	modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
    469 	if err == nil {
    470 		buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
    471 			if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
    472 				dialer.Timeout = dialerTimeout
    473 			}
    474 		})
    475 
    476 		buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
    477 			if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
    478 				transport.TLSHandshakeTimeout = tlsHandshakeTimeout
    479 			}
    480 		})
    481 	}
    482 
    483 	o.HTTPClient = buildable
    484 }
    485 
    486 func resolveRetryer(o *Options) {
    487 	if o.Retryer != nil {
    488 		return
    489 	}
    490 
    491 	if len(o.RetryMode) == 0 {
    492 		modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
    493 		if err == nil {
    494 			o.RetryMode = modeConfig.RetryMode
    495 		}
    496 	}
    497 	if len(o.RetryMode) == 0 {
    498 		o.RetryMode = aws.RetryModeStandard
    499 	}
    500 
    501 	var standardOptions []func(*retry.StandardOptions)
    502 	if v := o.RetryMaxAttempts; v != 0 {
    503 		standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
    504 			so.MaxAttempts = v
    505 		})
    506 	}
    507 
    508 	switch o.RetryMode {
    509 	case aws.RetryModeAdaptive:
    510 		var adaptiveOptions []func(*retry.AdaptiveModeOptions)
    511 		if len(standardOptions) != 0 {
    512 			adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
    513 				ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
    514 			})
    515 		}
    516 		o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
    517 
    518 	default:
    519 		o.Retryer = retry.NewStandard(standardOptions...)
    520 	}
    521 }
    522 
    523 func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
    524 	if cfg.Retryer == nil {
    525 		return
    526 	}
    527 	o.Retryer = cfg.Retryer()
    528 }
    529 
    530 func resolveAWSRetryMode(cfg aws.Config, o *Options) {
    531 	if len(cfg.RetryMode) == 0 {
    532 		return
    533 	}
    534 	o.RetryMode = cfg.RetryMode
    535 }
    536 func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
    537 	if cfg.RetryMaxAttempts == 0 {
    538 		return
    539 	}
    540 	o.RetryMaxAttempts = cfg.RetryMaxAttempts
    541 }
    542 
    543 func finalizeRetryMaxAttempts(o *Options) {
    544 	if o.RetryMaxAttempts == 0 {
    545 		return
    546 	}
    547 
    548 	o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
    549 }
    550 
    551 func finalizeOperationRetryMaxAttempts(o *Options, client Client) {
    552 	if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
    553 		return
    554 	}
    555 
    556 	o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
    557 }
    558 
    559 func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
    560 	if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
    561 		return
    562 	}
    563 	o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions)
    564 }
    565 
    566 func resolveInterceptors(cfg aws.Config, o *Options) {
    567 	o.Interceptors = cfg.Interceptors.Copy()
    568 }
    569 
    570 func addClientUserAgent(stack *middleware.Stack, options Options) error {
    571 	ua, err := getOrAddRequestUserAgent(stack)
    572 	if err != nil {
    573 		return err
    574 	}
    575 
    576 	ua.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sts", goModuleVersion)
    577 	if len(options.AppID) > 0 {
    578 		ua.AddSDKAgentKey(awsmiddleware.ApplicationIdentifier, options.AppID)
    579 	}
    580 
    581 	return nil
    582 }
    583 
    584 func getOrAddRequestUserAgent(stack *middleware.Stack) (*awsmiddleware.RequestUserAgent, error) {
    585 	id := (*awsmiddleware.RequestUserAgent)(nil).ID()
    586 	mw, ok := stack.Build.Get(id)
    587 	if !ok {
    588 		mw = awsmiddleware.NewRequestUserAgent()
    589 		if err := stack.Build.Add(mw, middleware.After); err != nil {
    590 			return nil, err
    591 		}
    592 	}
    593 
    594 	ua, ok := mw.(*awsmiddleware.RequestUserAgent)
    595 	if !ok {
    596 		return nil, fmt.Errorf("%T for %s middleware did not match expected type", mw, id)
    597 	}
    598 
    599 	return ua, nil
    600 }
    601 
    602 type HTTPSignerV4 interface {
    603 	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
    604 }
    605 
    606 func resolveHTTPSignerV4(o *Options) {
    607 	if o.HTTPSignerV4 != nil {
    608 		return
    609 	}
    610 	o.HTTPSignerV4 = newDefaultV4Signer(*o)
    611 }
    612 
    613 func newDefaultV4Signer(o Options) *v4.Signer {
    614 	return v4.NewSigner(func(so *v4.SignerOptions) {
    615 		so.Logger = o.Logger
    616 		so.LogSigning = o.ClientLogMode.IsSigning()
    617 	})
    618 }
    619 
    620 func addClientRequestID(stack *middleware.Stack) error {
    621 	return stack.Build.Add(&awsmiddleware.ClientRequestID{}, middleware.After)
    622 }
    623 
    624 func addComputeContentLength(stack *middleware.Stack) error {
    625 	return stack.Build.Add(&smithyhttp.ComputeContentLength{}, middleware.After)
    626 }
    627 
    628 func addRawResponseToMetadata(stack *middleware.Stack) error {
    629 	return stack.Deserialize.Add(&awsmiddleware.AddRawResponse{}, middleware.Before)
    630 }
    631 
    632 func addRecordResponseTiming(stack *middleware.Stack) error {
    633 	return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{}, middleware.After)
    634 }
    635 
    636 func addSpanRetryLoop(stack *middleware.Stack, options Options) error {
    637 	return stack.Finalize.Insert(&spanRetryLoop{options: options}, "Retry", middleware.Before)
    638 }
    639 
    640 type spanRetryLoop struct {
    641 	options Options
    642 }
    643 
    644 func (*spanRetryLoop) ID() string {
    645 	return "spanRetryLoop"
    646 }
    647 
    648 func (m *spanRetryLoop) HandleFinalize(
    649 	ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
    650 ) (
    651 	middleware.FinalizeOutput, middleware.Metadata, error,
    652 ) {
    653 	tracer := operationTracer(m.options.TracerProvider)
    654 	ctx, span := tracer.StartSpan(ctx, "RetryLoop")
    655 	defer span.End()
    656 
    657 	return next.HandleFinalize(ctx, in)
    658 }
    659 func addStreamingEventsPayload(stack *middleware.Stack) error {
    660 	return stack.Finalize.Add(&v4.StreamingEventsPayload{}, middleware.Before)
    661 }
    662 
    663 func addUnsignedPayload(stack *middleware.Stack) error {
    664 	return stack.Finalize.Insert(&v4.UnsignedPayload{}, "ResolveEndpointV2", middleware.After)
    665 }
    666 
    667 func addComputePayloadSHA256(stack *middleware.Stack) error {
    668 	return stack.Finalize.Insert(&v4.ComputePayloadSHA256{}, "ResolveEndpointV2", middleware.After)
    669 }
    670 
    671 func addContentSHA256Header(stack *middleware.Stack) error {
    672 	return stack.Finalize.Insert(&v4.ContentSHA256Header{}, (*v4.ComputePayloadSHA256)(nil).ID(), middleware.After)
    673 }
    674 
    675 func addIsWaiterUserAgent(o *Options) {
    676 	o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
    677 		ua, err := getOrAddRequestUserAgent(stack)
    678 		if err != nil {
    679 			return err
    680 		}
    681 
    682 		ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureWaiter)
    683 		return nil
    684 	})
    685 }
    686 
    687 func addIsPaginatorUserAgent(o *Options) {
    688 	o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
    689 		ua, err := getOrAddRequestUserAgent(stack)
    690 		if err != nil {
    691 			return err
    692 		}
    693 
    694 		ua.AddUserAgentFeature(awsmiddleware.UserAgentFeaturePaginator)
    695 		return nil
    696 	})
    697 }
    698 
    699 func addRetry(stack *middleware.Stack, o Options) error {
    700 	attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) {
    701 		m.LogAttempts = o.ClientLogMode.IsRetries()
    702 		m.OperationMeter = o.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/sts")
    703 	})
    704 	if err := stack.Finalize.Insert(attempt, "ResolveAuthScheme", middleware.Before); err != nil {
    705 		return err
    706 	}
    707 	if err := stack.Finalize.Insert(&retry.MetricsHeader{}, attempt.ID(), middleware.After); err != nil {
    708 		return err
    709 	}
    710 	return nil
    711 }
    712 
    713 // resolves dual-stack endpoint configuration
    714 func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
    715 	if len(cfg.ConfigSources) == 0 {
    716 		return nil
    717 	}
    718 	value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
    719 	if err != nil {
    720 		return err
    721 	}
    722 	if found {
    723 		o.EndpointOptions.UseDualStackEndpoint = value
    724 	}
    725 	return nil
    726 }
    727 
    728 // resolves FIPS endpoint configuration
    729 func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
    730 	if len(cfg.ConfigSources) == 0 {
    731 		return nil
    732 	}
    733 	value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
    734 	if err != nil {
    735 		return err
    736 	}
    737 	if found {
    738 		o.EndpointOptions.UseFIPSEndpoint = value
    739 	}
    740 	return nil
    741 }
    742 
    743 func resolveAccountID(identity smithyauth.Identity, mode aws.AccountIDEndpointMode) *string {
    744 	if mode == aws.AccountIDEndpointModeDisabled {
    745 		return nil
    746 	}
    747 
    748 	if ca, ok := identity.(*internalauthsmithy.CredentialsAdapter); ok && ca.Credentials.AccountID != "" {
    749 		return aws.String(ca.Credentials.AccountID)
    750 	}
    751 
    752 	return nil
    753 }
    754 
    755 func addTimeOffsetBuild(stack *middleware.Stack, c *Client) error {
    756 	mw := internalmiddleware.AddTimeOffsetMiddleware{Offset: c.timeOffset}
    757 	if err := stack.Build.Add(&mw, middleware.After); err != nil {
    758 		return err
    759 	}
    760 	return stack.Deserialize.Insert(&mw, "RecordResponseTiming", middleware.Before)
    761 }
    762 func initializeTimeOffsetResolver(c *Client) {
    763 	c.timeOffset = new(atomic.Int64)
    764 }
    765 
    766 func addUserAgentRetryMode(stack *middleware.Stack, options Options) error {
    767 	ua, err := getOrAddRequestUserAgent(stack)
    768 	if err != nil {
    769 		return err
    770 	}
    771 
    772 	switch options.Retryer.(type) {
    773 	case *retry.Standard:
    774 		ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeStandard)
    775 	case *retry.AdaptiveMode:
    776 		ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeAdaptive)
    777 	}
    778 	return nil
    779 }
    780 
    781 type setCredentialSourceMiddleware struct {
    782 	ua      *awsmiddleware.RequestUserAgent
    783 	options Options
    784 }
    785 
    786 func (m setCredentialSourceMiddleware) ID() string { return "SetCredentialSourceMiddleware" }
    787 
    788 func (m setCredentialSourceMiddleware) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
    789 	out middleware.BuildOutput, metadata middleware.Metadata, err error,
    790 ) {
    791 	asProviderSource, ok := m.options.Credentials.(aws.CredentialProviderSource)
    792 	if !ok {
    793 		return next.HandleBuild(ctx, in)
    794 	}
    795 	providerSources := asProviderSource.ProviderSources()
    796 	for _, source := range providerSources {
    797 		m.ua.AddCredentialsSource(source)
    798 	}
    799 	return next.HandleBuild(ctx, in)
    800 }
    801 
    802 func addCredentialSource(stack *middleware.Stack, options Options) error {
    803 	ua, err := getOrAddRequestUserAgent(stack)
    804 	if err != nil {
    805 		return err
    806 	}
    807 
    808 	mw := setCredentialSourceMiddleware{ua: ua, options: options}
    809 	return stack.Build.Insert(&mw, "UserAgent", middleware.Before)
    810 }
    811 
    812 func resolveTracerProvider(options *Options) {
    813 	if options.TracerProvider == nil {
    814 		options.TracerProvider = &tracing.NopTracerProvider{}
    815 	}
    816 }
    817 
    818 func resolveMeterProvider(options *Options) {
    819 	if options.MeterProvider == nil {
    820 		options.MeterProvider = metrics.NopMeterProvider{}
    821 	}
    822 }
    823 
    824 func addRecursionDetection(stack *middleware.Stack) error {
    825 	return stack.Build.Add(&awsmiddleware.RecursionDetection{}, middleware.After)
    826 }
    827 
    828 func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
    829 	return stack.Deserialize.Insert(&awsmiddleware.RequestIDRetriever{}, "OperationDeserializer", middleware.Before)
    830 
    831 }
    832 
    833 func addResponseErrorMiddleware(stack *middleware.Stack) error {
    834 	return stack.Deserialize.Insert(&awshttp.ResponseErrorWrapper{}, "RequestIDRetriever", middleware.Before)
    835 
    836 }
    837 
    838 // HTTPPresignerV4 represents presigner interface used by presign url client
    839 type HTTPPresignerV4 interface {
    840 	PresignHTTP(
    841 		ctx context.Context, credentials aws.Credentials, r *http.Request,
    842 		payloadHash string, service string, region string, signingTime time.Time,
    843 		optFns ...func(*v4.SignerOptions),
    844 	) (url string, signedHeader http.Header, err error)
    845 }
    846 
    847 // PresignOptions represents the presign client options
    848 type PresignOptions struct {
    849 
    850 	// ClientOptions are list of functional options to mutate client options used by
    851 	// the presign client.
    852 	ClientOptions []func(*Options)
    853 
    854 	// Presigner is the presigner used by the presign url client
    855 	Presigner HTTPPresignerV4
    856 }
    857 
    858 func (o PresignOptions) copy() PresignOptions {
    859 	clientOptions := make([]func(*Options), len(o.ClientOptions))
    860 	copy(clientOptions, o.ClientOptions)
    861 	o.ClientOptions = clientOptions
    862 	return o
    863 }
    864 
    865 // WithPresignClientFromClientOptions is a helper utility to retrieve a function
    866 // that takes PresignOption as input
    867 func WithPresignClientFromClientOptions(optFns ...func(*Options)) func(*PresignOptions) {
    868 	return withPresignClientFromClientOptions(optFns).options
    869 }
    870 
    871 type withPresignClientFromClientOptions []func(*Options)
    872 
    873 func (w withPresignClientFromClientOptions) options(o *PresignOptions) {
    874 	o.ClientOptions = append(o.ClientOptions, w...)
    875 }
    876 
    877 // PresignClient represents the presign url client
    878 type PresignClient struct {
    879 	client  *Client
    880 	options PresignOptions
    881 }
    882 
    883 // NewPresignClient generates a presign client using provided API Client and
    884 // presign options
    885 func NewPresignClient(c *Client, optFns ...func(*PresignOptions)) *PresignClient {
    886 	var options PresignOptions
    887 	for _, fn := range optFns {
    888 		fn(&options)
    889 	}
    890 	if len(options.ClientOptions) != 0 {
    891 		c = New(c.options, options.ClientOptions...)
    892 	}
    893 
    894 	if options.Presigner == nil {
    895 		options.Presigner = newDefaultV4Signer(c.options)
    896 	}
    897 
    898 	return &PresignClient{
    899 		client:  c,
    900 		options: options,
    901 	}
    902 }
    903 
    904 func withNopHTTPClientAPIOption(o *Options) {
    905 	o.HTTPClient = smithyhttp.NopClient{}
    906 }
    907 
    908 type presignContextPolyfillMiddleware struct {
    909 }
    910 
    911 func (*presignContextPolyfillMiddleware) ID() string {
    912 	return "presignContextPolyfill"
    913 }
    914 
    915 func (m *presignContextPolyfillMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
    916 	out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
    917 ) {
    918 	rscheme := getResolvedAuthScheme(ctx)
    919 	if rscheme == nil {
    920 		return out, metadata, fmt.Errorf("no resolved auth scheme")
    921 	}
    922 
    923 	schemeID := rscheme.Scheme.SchemeID()
    924 
    925 	if schemeID == "aws.auth#sigv4" || schemeID == "com.amazonaws.s3#sigv4express" {
    926 		if sn, ok := smithyhttp.GetSigV4SigningName(&rscheme.SignerProperties); ok {
    927 			ctx = awsmiddleware.SetSigningName(ctx, sn)
    928 		}
    929 		if sr, ok := smithyhttp.GetSigV4SigningRegion(&rscheme.SignerProperties); ok {
    930 			ctx = awsmiddleware.SetSigningRegion(ctx, sr)
    931 		}
    932 	} else if schemeID == "aws.auth#sigv4a" {
    933 		if sn, ok := smithyhttp.GetSigV4ASigningName(&rscheme.SignerProperties); ok {
    934 			ctx = awsmiddleware.SetSigningName(ctx, sn)
    935 		}
    936 		if sr, ok := smithyhttp.GetSigV4ASigningRegions(&rscheme.SignerProperties); ok {
    937 			ctx = awsmiddleware.SetSigningRegion(ctx, sr[0])
    938 		}
    939 	}
    940 
    941 	return next.HandleFinalize(ctx, in)
    942 }
    943 
    944 type presignConverter PresignOptions
    945 
    946 func (c presignConverter) convertToPresignMiddleware(stack *middleware.Stack, options Options) (err error) {
    947 	if _, ok := stack.Finalize.Get((*acceptencodingcust.DisableGzip)(nil).ID()); ok {
    948 		stack.Finalize.Remove((*acceptencodingcust.DisableGzip)(nil).ID())
    949 	}
    950 	if _, ok := stack.Finalize.Get((*retry.Attempt)(nil).ID()); ok {
    951 		stack.Finalize.Remove((*retry.Attempt)(nil).ID())
    952 	}
    953 	if _, ok := stack.Finalize.Get((*retry.MetricsHeader)(nil).ID()); ok {
    954 		stack.Finalize.Remove((*retry.MetricsHeader)(nil).ID())
    955 	}
    956 	stack.Deserialize.Clear()
    957 	stack.Build.Remove((*awsmiddleware.ClientRequestID)(nil).ID())
    958 	stack.Build.Remove("UserAgent")
    959 	if err := stack.Finalize.Insert(&presignContextPolyfillMiddleware{}, "Signing", middleware.Before); err != nil {
    960 		return err
    961 	}
    962 
    963 	pmw := v4.NewPresignHTTPRequestMiddleware(v4.PresignHTTPRequestMiddlewareOptions{
    964 		CredentialsProvider: options.Credentials,
    965 		Presigner:           c.Presigner,
    966 		LogSigning:          options.ClientLogMode.IsSigning(),
    967 	})
    968 	if _, err := stack.Finalize.Swap("Signing", pmw); err != nil {
    969 		return err
    970 	}
    971 	if err = smithyhttp.AddNoPayloadDefaultContentTypeRemover(stack); err != nil {
    972 		return err
    973 	}
    974 	// convert request to a GET request
    975 	err = query.AddAsGetRequestMiddleware(stack)
    976 	if err != nil {
    977 		return err
    978 	}
    979 	err = presignedurlcust.AddAsIsPresigningMiddleware(stack)
    980 	if err != nil {
    981 		return err
    982 	}
    983 	return nil
    984 }
    985 
    986 func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
    987 	return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
    988 		LogRequest:          o.ClientLogMode.IsRequest(),
    989 		LogRequestWithBody:  o.ClientLogMode.IsRequestWithBody(),
    990 		LogResponse:         o.ClientLogMode.IsResponse(),
    991 		LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
    992 	}, middleware.After)
    993 }
    994 
    995 type disableHTTPSMiddleware struct {
    996 	DisableHTTPS bool
    997 }
    998 
    999 func (*disableHTTPSMiddleware) ID() string {
   1000 	return "disableHTTPS"
   1001 }
   1002 
   1003 func (m *disableHTTPSMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
   1004 	out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
   1005 ) {
   1006 	req, ok := in.Request.(*smithyhttp.Request)
   1007 	if !ok {
   1008 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   1009 	}
   1010 
   1011 	if m.DisableHTTPS && !smithyhttp.GetHostnameImmutable(ctx) {
   1012 		req.URL.Scheme = "http"
   1013 	}
   1014 
   1015 	return next.HandleFinalize(ctx, in)
   1016 }
   1017 
   1018 func addDisableHTTPSMiddleware(stack *middleware.Stack, o Options) error {
   1019 	return stack.Finalize.Insert(&disableHTTPSMiddleware{
   1020 		DisableHTTPS: o.EndpointOptions.DisableHTTPS,
   1021 	}, "ResolveEndpointV2", middleware.After)
   1022 }
   1023 
   1024 func addInterceptBeforeRetryLoop(stack *middleware.Stack, opts Options) error {
   1025 	return stack.Finalize.Insert(&smithyhttp.InterceptBeforeRetryLoop{
   1026 		Interceptors: opts.Interceptors.BeforeRetryLoop,
   1027 	}, "Retry", middleware.Before)
   1028 }
   1029 
   1030 func addInterceptAttempt(stack *middleware.Stack, opts Options) error {
   1031 	return stack.Finalize.Insert(&smithyhttp.InterceptAttempt{
   1032 		BeforeAttempt: opts.Interceptors.BeforeAttempt,
   1033 		AfterAttempt:  opts.Interceptors.AfterAttempt,
   1034 	}, "Retry", middleware.After)
   1035 }
   1036 
   1037 func addInterceptExecution(stack *middleware.Stack, opts Options) error {
   1038 	return stack.Initialize.Add(&smithyhttp.InterceptExecution{
   1039 		BeforeExecution: opts.Interceptors.BeforeExecution,
   1040 		AfterExecution:  opts.Interceptors.AfterExecution,
   1041 	}, middleware.Before)
   1042 }
   1043 
   1044 func addInterceptBeforeSerialization(stack *middleware.Stack, opts Options) error {
   1045 	return stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{
   1046 		Interceptors: opts.Interceptors.BeforeSerialization,
   1047 	}, "OperationSerializer", middleware.Before)
   1048 }
   1049 
   1050 func addInterceptAfterSerialization(stack *middleware.Stack, opts Options) error {
   1051 	return stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{
   1052 		Interceptors: opts.Interceptors.AfterSerialization,
   1053 	}, "OperationSerializer", middleware.After)
   1054 }
   1055 
   1056 func addInterceptBeforeSigning(stack *middleware.Stack, opts Options) error {
   1057 	return stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{
   1058 		Interceptors: opts.Interceptors.BeforeSigning,
   1059 	}, "Signing", middleware.Before)
   1060 }
   1061 
   1062 func addInterceptAfterSigning(stack *middleware.Stack, opts Options) error {
   1063 	return stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{
   1064 		Interceptors: opts.Interceptors.AfterSigning,
   1065 	}, "Signing", middleware.After)
   1066 }
   1067 
   1068 func addInterceptTransmit(stack *middleware.Stack, opts Options) error {
   1069 	return stack.Deserialize.Add(&smithyhttp.InterceptTransmit{
   1070 		BeforeTransmit: opts.Interceptors.BeforeTransmit,
   1071 		AfterTransmit:  opts.Interceptors.AfterTransmit,
   1072 	}, middleware.After)
   1073 }
   1074 
   1075 func addInterceptBeforeDeserialization(stack *middleware.Stack, opts Options) error {
   1076 	return stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{
   1077 		Interceptors: opts.Interceptors.BeforeDeserialization,
   1078 	}, "OperationDeserializer", middleware.After) // (deserialize stack is called in reverse)
   1079 }
   1080 
   1081 func addInterceptAfterDeserialization(stack *middleware.Stack, opts Options) error {
   1082 	return stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{
   1083 		Interceptors: opts.Interceptors.AfterDeserialization,
   1084 	}, "OperationDeserializer", middleware.Before)
   1085 }
   1086 
   1087 type spanInitializeStart struct {
   1088 }
   1089 
   1090 func (*spanInitializeStart) ID() string {
   1091 	return "spanInitializeStart"
   1092 }
   1093 
   1094 func (m *spanInitializeStart) HandleInitialize(
   1095 	ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
   1096 ) (
   1097 	middleware.InitializeOutput, middleware.Metadata, error,
   1098 ) {
   1099 	ctx, _ = tracing.StartSpan(ctx, "Initialize")
   1100 
   1101 	return next.HandleInitialize(ctx, in)
   1102 }
   1103 
   1104 type spanInitializeEnd struct {
   1105 }
   1106 
   1107 func (*spanInitializeEnd) ID() string {
   1108 	return "spanInitializeEnd"
   1109 }
   1110 
   1111 func (m *spanInitializeEnd) HandleInitialize(
   1112 	ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
   1113 ) (
   1114 	middleware.InitializeOutput, middleware.Metadata, error,
   1115 ) {
   1116 	ctx, span := tracing.PopSpan(ctx)
   1117 	span.End()
   1118 
   1119 	return next.HandleInitialize(ctx, in)
   1120 }
   1121 
   1122 type spanBuildRequestStart struct {
   1123 }
   1124 
   1125 func (*spanBuildRequestStart) ID() string {
   1126 	return "spanBuildRequestStart"
   1127 }
   1128 
   1129 func (m *spanBuildRequestStart) HandleSerialize(
   1130 	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
   1131 ) (
   1132 	middleware.SerializeOutput, middleware.Metadata, error,
   1133 ) {
   1134 	ctx, _ = tracing.StartSpan(ctx, "BuildRequest")
   1135 
   1136 	return next.HandleSerialize(ctx, in)
   1137 }
   1138 
   1139 type spanBuildRequestEnd struct {
   1140 }
   1141 
   1142 func (*spanBuildRequestEnd) ID() string {
   1143 	return "spanBuildRequestEnd"
   1144 }
   1145 
   1146 func (m *spanBuildRequestEnd) HandleBuild(
   1147 	ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
   1148 ) (
   1149 	middleware.BuildOutput, middleware.Metadata, error,
   1150 ) {
   1151 	ctx, span := tracing.PopSpan(ctx)
   1152 	span.End()
   1153 
   1154 	return next.HandleBuild(ctx, in)
   1155 }
   1156 
   1157 func addSpanInitializeStart(stack *middleware.Stack) error {
   1158 	return stack.Initialize.Add(&spanInitializeStart{}, middleware.Before)
   1159 }
   1160 
   1161 func addSpanInitializeEnd(stack *middleware.Stack) error {
   1162 	return stack.Initialize.Add(&spanInitializeEnd{}, middleware.After)
   1163 }
   1164 
   1165 func addSpanBuildRequestStart(stack *middleware.Stack) error {
   1166 	return stack.Serialize.Add(&spanBuildRequestStart{}, middleware.Before)
   1167 }
   1168 
   1169 func addSpanBuildRequestEnd(stack *middleware.Stack) error {
   1170 	return stack.Build.Add(&spanBuildRequestEnd{}, middleware.After)
   1171 }
	src Go monorepo.
	git clone git://code.dwrz.net/src
	Log \| Files \| Refs