func CreateGateway()

in runtime/gateway.go [163:290]
108 lines of code
24 McCabe index (conditional complexity)

func CreateGateway(
	config *StaticConfig, opts *Options,
) (*Gateway, error) {
	var metricsBackend tally.CachedStatsReporter
	var metricsDefaultBuckets tally.Buckets
	var logWriter zapcore.WriteSyncer
	var scopeTagsExtractors []ContextScopeTagsExtractor
	var logFieldsExtractors []ContextLogFieldsExtractor
	var jsonWrapper jsonwrapper.JSONWrapper

	if opts == nil {
		opts = &Options{}
	}
	if opts.MetricsBackend != nil {
		metricsBackend = opts.MetricsBackend
	}
	if opts.MetricsDefaultBuckets != nil {
		metricsDefaultBuckets = opts.MetricsDefaultBuckets
	} else {
		metricsDefaultBuckets = tally.DefaultBuckets
	}
	if opts.LogWriter != nil {
		logWriter = opts.LogWriter
	}
	if opts.JSONWrapper != nil {
		jsonWrapper = opts.JSONWrapper
	} else {
		jsonWrapper = jsonwrapper.NewDefaultJSONWrapper()
	}

	if opts.GetContextScopeExtractors != nil {
		scopeTagsExtractors = opts.GetContextScopeExtractors()
	} else {
		scopeTagsExtractors = []ContextScopeTagsExtractor{GetEndpointRequestHeadersFromCtx}
	}

	if opts.GetContextFieldExtractors != nil {
		logFieldsExtractors = opts.GetContextFieldExtractors()
	} else {
		logFieldsExtractors = []ContextLogFieldsExtractor{
			func(ctx context.Context) []zap.Field {
				reqHeaders := GetEndpointRequestHeadersFromCtx(ctx)
				fields := make([]zap.Field, 0, len(reqHeaders))
				for k, v := range reqHeaders {
					fields = append(fields, zap.String(k, v))
				}
				return fields
			},
		}
	}

	extractors := &ContextExtractors{
		ScopeTagsExtractors: scopeTagsExtractors,
		LogFieldsExtractors: logFieldsExtractors,
	}

	var service string
	if config.ContainsKey(serviceFromEnvKey) {
		service = os.Getenv(config.MustGetString(serviceFromEnvKey))
	}
	if service == "" {
		service = config.MustGetString("serviceName")
	}

	gateway := &Gateway{
		HTTPPort:              int32(config.MustGetInt("http.port")),
		TChannelPort:          int32(config.MustGetInt("tchannel.port")),
		ServiceName:           service,
		WaitGroup:             &sync.WaitGroup{},
		Config:                config,
		ContextExtractor:      extractors,
		JSONWrapper:           jsonWrapper,
		logWriter:             logWriter,
		metricsBackend:        metricsBackend,
		metricsDefaultBuckets: metricsDefaultBuckets,
		requestUUIDHeaderKey:  opts.RequestUUIDHeaderKey,
	}

	gateway.setupConfig(config)
	config.Freeze()

	// order matters for following setup method calls
	if err := gateway.setupMetrics(config); err != nil {
		return nil, err
	}

	if err := gateway.setupLogger(config); err != nil {
		return nil, err
	}

	if opts.Tracer != nil &&
		opts.TracerCloser != nil &&
		config.ContainsKey("jaeger.tracer.custom") &&
		config.MustGetBoolean("jaeger.tracer.custom") {
		gateway.Tracer = opts.Tracer
		gateway.tracerCloser = opts.TracerCloser
	} else {
		if err := gateway.setupTracer(config); err != nil {
			return nil, err
		}
	}

	if opts.NotFoundHandler != nil &&
		config.ContainsKey("http.notFoundHandler.custom") &&
		config.MustGetBoolean("http.notFoundHandler.custom") {
		gateway.notFoundHandler = opts.NotFoundHandler(gateway)
	}

	// setup router after metrics and logs
	gateway.HTTPRouter = NewHTTPRouter(gateway)

	if err := gateway.setupHTTPServer(); err != nil {
		return nil, err
	}

	if err := gateway.setupServerTChannel(config); err != nil {
		return nil, err
	}

	// setup gRPC client dispatcher after metrics, logger and tracer
	if err := gateway.setupGRPCClientDispatcher(config); err != nil {
		return nil, err
	}

	gateway.registerPredefined()

	return gateway, nil
}