fun build()

in agent-sdk/src/main/java/co/elastic/otel/android/internal/opentelemetry/ElasticOpenTelemetry.kt [140:240]
101 lines of code
2 McCabe index (conditional complexity)

        fun build(serviceManager: ServiceManager): ElasticOpenTelemetry {
            val commonAttributesInterceptor =
                CommonAttributesInterceptor(serviceManager, sessionProvider)
            addSpanAttributesInterceptor(commonAttributesInterceptor)
            addSpanAttributesInterceptor(SpanAttributesInterceptor(serviceManager))
            addLogRecordAttributesInterceptor(commonAttributesInterceptor)
            if (appInstallationIdProvider == null) {
                appInstallationIdProvider = PreferencesCachedStringProvider(
                    serviceManager,
                    "app_installation_id"
                ) { UUID.randomUUID().toString() }
            }
            val finalProcessorFactory = processorFactory
                ?: DefaultProcessorFactory(serviceManager.getBackgroundWorkService())
            var resource = Resource.builder()
                .put(ServiceAttributes.SERVICE_NAME, serviceName)
                .put(
                    ServiceAttributes.SERVICE_VERSION,
                    serviceVersion ?: serviceManager.getAppInfoService().getVersionName()
                    ?: "unknown"
                )
                .put(DeploymentIncubatingAttributes.DEPLOYMENT_ENVIRONMENT, deploymentEnvironment)
                .put(
                    AttributeKey.stringKey("app.installation.id"),
                    appInstallationIdProvider!!.get()
                )
                .put(DeviceIncubatingAttributes.DEVICE_MODEL_IDENTIFIER, Build.MODEL)
                .put(DeviceIncubatingAttributes.DEVICE_MANUFACTURER, Build.MANUFACTURER)
                .put(OsIncubatingAttributes.OS_DESCRIPTION, getOsDescription())
                .put(OsIncubatingAttributes.OS_VERSION, Build.VERSION.RELEASE)
                .put(OsIncubatingAttributes.OS_NAME, "Android")
                .put(ProcessIncubatingAttributes.PROCESS_RUNTIME_NAME, "Android Runtime")
                .put(
                    ProcessIncubatingAttributes.PROCESS_RUNTIME_VERSION,
                    System.getProperty("java.vm.version")
                )
                .put(TelemetryAttributes.TELEMETRY_SDK_NAME, "android")
                .put(TelemetryAttributes.TELEMETRY_SDK_VERSION, BuildConfig.APM_AGENT_VERSION)
                .put(TelemetryAttributes.TELEMETRY_SDK_LANGUAGE, "java")
                .build()
            resource = resourceInterceptor?.intercept(resource) ?: resource
            val openTelemetryBuilder = OpenTelemetrySdk.builder()
            val spanExporter = exporterProvider.getSpanExporter()?.let {
                Interceptor.composite(spanExporterInterceptors).intercept(it)
            }
            val logRecordExporter = exporterProvider.getLogRecordExporter()?.let {
                Interceptor.composite(logRecordExporterInterceptors).intercept(it)
            }
            val metricExporter = exporterProvider.getMetricExporter()?.let {
                Interceptor.composite(metricExporterInterceptors).intercept(it)
            }
            finalProcessorFactory.createSpanProcessor(spanExporter)?.let {
                openTelemetryBuilder.setTracerProvider(
                    SdkTracerProvider.builder()
                        .setClock(clock)
                        .setResource(resource)
                        .addSpanProcessor(
                            SpanAttributesProcessor(
                                Interceptor.composite(
                                    spanAttributesInterceptors
                                )
                            )
                        )
                        .addSpanProcessor(it)
                        .build()
                )
            }
            finalProcessorFactory.createLogRecordProcessor(logRecordExporter)
                ?.let {
                    openTelemetryBuilder.setLoggerProvider(
                        SdkLoggerProvider.builder()
                            .setClock(clock)
                            .setResource(resource)
                            .addLogRecordProcessor(
                                LogRecordAttributesProcessor(
                                    Interceptor.composite(
                                        logRecordAttributesInterceptors
                                    )
                                )
                            )
                            .addLogRecordProcessor(it)
                            .build()
                    )
                }
            finalProcessorFactory.createMetricReader(metricExporter)?.let {
                openTelemetryBuilder.setMeterProvider(
                    SdkMeterProvider.builder()
                        .setClock(clock)
                        .setResource(resource)
                        .registerMetricReader(it)
                        .build()
                )
            }
            openTelemetryBuilder.setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
            return ElasticOpenTelemetry(
                openTelemetryBuilder.build(),
                serviceName,
                deploymentEnvironment,
                clock
            )
        }