SentryTelemetryService.kt

@file:Suppress("UnstableApiUsage")

package io.sentry.android.gradle.telemetry

import com.android.build.api.dsl.CommonExtension
import io.sentry.BuildConfig
import io.sentry.IScopes
import io.sentry.ISpan
import io.sentry.ITransaction
import io.sentry.NoOpScopes
import io.sentry.Sentry
import io.sentry.SentryEvent
import io.sentry.SentryLevel
import io.sentry.SpanStatus
import io.sentry.TransactionOptions
import io.sentry.android.gradle.SentryPlugin
import io.sentry.android.gradle.SentryPlugin.Companion.logger
import io.sentry.android.gradle.SentryPropertiesFileProvider
import io.sentry.android.gradle.defaultOrgProvider
import io.sentry.android.gradle.extensions.SentryPluginExtension
import io.sentry.android.gradle.util.AgpVersions
import io.sentry.android.gradle.util.SentryCliException
import io.sentry.android.gradle.util.error
import io.sentry.android.gradle.util.getBuildServiceName
import io.sentry.android.gradle.util.info
import io.sentry.exception.ExceptionMechanismException
import io.sentry.gradle.common.SentryVariant
import io.sentry.protocol.Mechanism
import io.sentry.protocol.User
import java.util.concurrent.atomic.AtomicBoolean
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationDetails
import org.gradle.api.provider.Provider
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters.None
import org.gradle.execution.RunRootBuildWorkBuildOperationType
import org.gradle.internal.operations.BuildOperationDescriptor
import org.gradle.internal.operations.BuildOperationListener
import org.gradle.internal.operations.OperationFinishEvent
import org.gradle.internal.operations.OperationIdentifier
import org.gradle.internal.operations.OperationProgressEvent
import org.gradle.internal.operations.OperationStartEvent
import org.gradle.util.GradleVersion

abstract class SentryTelemetryService : BuildService<None>, BuildOperationListener, AutoCloseable {

  private var scopes: IScopes = NoOpScopes.getInstance()
  private var transaction: ITransaction? = null
  private var didAddChildSpans: Boolean = false
  private var started: Boolean = false
  private var orgProvider: Provider<String>? = null
  private val orgAttached = AtomicBoolean(false)

  @Synchronized
  fun start(paramsCallback: () -> SentryTelemetryServiceParams) {
    if (started) {
      return
    }
    val startParameters = paramsCallback()

    try {
      if (startParameters.saas == false) {
        SentryPlugin.logger.info {
          "Sentry is running against a self hosted instance. " + "Telemetry has been disabled."
        }
        scopes = NoOpScopes.getInstance()
      } else if (!startParameters.sendTelemetry) {
        SentryPlugin.logger.info { "Sentry telemetry has been disabled." }
        scopes = NoOpScopes.getInstance()
      } else {
        if (!Sentry.isEnabled()) {
          SentryPlugin.logger.info {
            "Sentry telemetry is enabled. To disable set `telemetry=false` " +
              "in the sentry config block."
          }
          Sentry.init { options ->
            options.dsn = startParameters.dsn
            options.isDebug = startParameters.isDebug
            options.isEnablePrettySerializationOutput = false
            options.tracesSampleRate = 1.0
            options.release = BuildConfig.Version
            options.isSendModules = false
            options.environment = startParameters.buildType
            options.setTag("SDK_VERSION", BuildConfig.SdkVersion)
            options.setTag("BUILD_SYSTEM", "gradle")
            options.setTag("GRADLE_VERSION", GradleVersion.current().version)
            startParameters.cliVersion?.let { options.setTag("SENTRY_CLI_VERSION", it) }

            startParameters.extraTags.forEach { (key, value) -> options.setTag(key, value) }

            try {
              options.setTag("AGP_VERSION", AgpVersions.CURRENT.toString())
            } catch (t: Throwable) {}
          }
        }
        scopes = Sentry.getCurrentScopes()
        startRun("gradle build ${startParameters.buildType}")

        scopes.configureScope { scope ->
          scope.user =
            User().also { user -> startParameters.sentryOrganization?.let { user.id = it } }
        }

        orgProvider = startParameters.cliOrgProvider

        started = true
      }
    } catch (t: Throwable) {
      SentryPlugin.logger.error(t) { "Sentry failed to initialize." }
    }
  }

  override fun started(descriptor: BuildOperationDescriptor, event: OperationStartEvent) {}

  override fun progress(identifier: OperationIdentifier, event: OperationProgressEvent) {}

  override fun finished(
    buildOperationDescriptor: BuildOperationDescriptor,
    operationFinishEvent: OperationFinishEvent,
  ) {
    val details = buildOperationDescriptor.details

    operationFinishEvent.failure?.let { error ->
      if (isSentryError(error, details)) {
        captureError(error, "build")
        transaction?.status = SpanStatus.UNKNOWN_ERROR
      }
    }

    if (details is RunRootBuildWorkBuildOperationType.Details) {
      endRun()
    }
  }

  private fun isSentryError(throwable: Throwable, details: Any?): Boolean {
    val isSentryTaskName =
      (details as? ExecuteTaskBuildOperationDetails)?.let {
        it.task.name.substringAfterLast(":").contains("sentry", ignoreCase = true)
      } ?: false
    return isSentryTaskName ||
      throwable.stackTrace.any {
        it.className.startsWith("io.sentry") &&
          !(it.className.contains("test", ignoreCase = true) ||
            it.className.contains("rule", ignoreCase = true))
      }
  }

  fun captureError(exception: Throwable, operation: String?) {
    val message =
      if (exception is SentryCliException) {
        "$operation failed with SentryCliException and reason ${exception.reason}"
      } else {
        "$operation failed with ${exception.javaClass}"
      }

    val mechanism =
      Mechanism().also {
        it.type = MECHANISM_TYPE
        it.isHandled = false
      }
    val mechanismException: Throwable =
      ExceptionMechanismException(
        mechanism,
        SentryMinimalException(message),
        Thread.currentThread(),
      )
    val event = SentryEvent(mechanismException).also { it.level = SentryLevel.FATAL }
    scopes.captureEvent(event)
  }

  fun startRun(transactionName: String) {
    scopes.startSession()
    val options = TransactionOptions()
    options.isBindToScope = true
    transaction = scopes.startTransaction(transactionName, "build", options)
  }

  fun endRun() {
    if (didAddChildSpans) {
      transaction?.finish()
      scopes.endSession()
    }
  }

  fun traceCli(): List<String> {
    val args = mutableListOf<String>()
    scopes.traceparent?.let { header ->
      args.add("--header")
      args.add("${header.name}:${header.value}")
    }
    scopes.baggage?.let { header ->
      args.add("--header")
      args.add("${header.name}:${header.value}")
    }
    return args
  }

  fun startTask(operation: String): ISpan? {
    didAddChildSpans = true
    attachDefaultOrg()
    scopes.setTag("step", operation)
    return scopes.span?.startChild(operation)
  }

  // Resolves the default org (via the SentryOrgValueSource provider) on the first tracked task and
  // attaches it to the telemetry scope. Querying the provider here, during task execution, keeps
  // the underlying sentry-cli process out of the configuration phase so the configuration cache
  // stays valid. An explicitly configured org already set on the scope is left untouched.
  private fun attachDefaultOrg() {
    if (!orgAttached.compareAndSet(false, true)) {
      return
    }
    orgProvider?.orNull?.let { org ->
      scopes.configureScope { scope ->
        if (scope.user?.id == null) {
          scope.user = User().also { it.id = org }
        }
      }
    }
  }

  fun endTask(span: ISpan?, task: Task) {
    span?.let { span ->
      task.state.failure?.let { throwable ->
        captureError(throwable, span.operation)
        span.status = SpanStatus.UNKNOWN_ERROR
      }

      span.finish()
    }
  }

  override fun close() {
    if (transaction?.isFinished == false) {
      endRun()
    }
    Sentry.close()
  }

  companion object {
    val SENTRY_SAAS_DSN: String =
      "https://000e5dea9770b4537055f8a6d28c021e@o1.ingest.sentry.io/4506241308295168"
    val MECHANISM_TYPE: String = "GradleTelemetry"

    fun createParameters(
      project: Project,
      variant: SentryVariant?,
      extension: SentryPluginExtension,
      sentryOrg: String?,
      buildType: String,
    ): SentryTelemetryServiceParams {
      val tags = extraTagsFromExtension(project, extension)
      val org = sentryOrg ?: extension.org.orNull

      return SentryTelemetryServiceParams(
        extension.telemetry.get(),
        extension.telemetryDsn.get(),
        org,
        buildType,
        tags,
        extension.debug.get(),
        saas = extension.url.orNull == null,
        cliVersion = BuildConfig.CliVersion,
        cliOrgProvider =
          project.defaultOrgProvider(
            extension.url.orNull,
            extension.authToken.orNull,
            variant?.let { SentryPropertiesFileProvider.getPropertiesFilePath(project, it) },
          ),
      )
    }

    fun register(project: Project): Provider<SentryTelemetryService> {
      return project.gradle.sharedServices.registerIfAbsent(
        getBuildServiceName(SentryTelemetryService::class.java),
        SentryTelemetryService::class.java,
      ) {}
    }

    private fun extraTagsFromExtension(
      project: Project,
      extension: SentryPluginExtension,
    ): Map<String, String> {
      val tags = mutableMapOf<String, String>()

      tags.put("debug", extension.debug.get().toString())
      tags.put("includeProguardMapping", extension.includeProguardMapping.get().toString())
      tags.put("autoUploadProguardMapping", extension.autoUploadProguardMapping.get().toString())
      tags.put("autoUpload", extension.autoUpload.get().toString())
      tags.put("uploadNativeSymbols", extension.uploadNativeSymbols.get().toString())
      tags.put("autoUploadNativeSymbols", extension.autoUploadNativeSymbols.get().toString())
      tags.put("includeNativeSources", extension.includeNativeSources.get().toString())
      tags.put("ignoredVariants_set", extension.ignoredVariants.get().isNotEmpty().toString())
      tags.put("ignoredBuildTypes_set", extension.ignoredBuildTypes.get().isNotEmpty().toString())
      tags.put("ignoredFlavors_set", extension.ignoredFlavors.get().isNotEmpty().toString())
      tags.put("dexguardEnabled", extension.dexguardEnabled.get().toString())
      tags.put("tracing_enabled", extension.tracingInstrumentation.enabled.get().toString())
      tags.put("tracing_debug", extension.tracingInstrumentation.debug.get().toString())
      tags.put(
        "tracing_forceInstrumentDependencies",
        extension.tracingInstrumentation.forceInstrumentDependencies.get().toString(),
      )
      tags.put("tracing_features", extension.tracingInstrumentation.features.get().toString())
      tags.put(
        "tracing_logcat_enabled",
        extension.tracingInstrumentation.logcat.enabled.get().toString(),
      )
      tags.put(
        "tracing_logcat_minLevel",
        extension.tracingInstrumentation.logcat.minLevel.get().toString(),
      )
      tags.put("autoInstallation_enabled", extension.autoInstallation.enabled.get().toString())
      tags.put(
        "autoInstallation_sentryVersion",
        extension.autoInstallation.sentryVersion.get().toString(),
      )
      tags.put(
        "autoInstallation_verifyOpenTelemetryVersions",
        extension.autoInstallation.verifyOpenTelemetryVersions.get().toString(),
      )
      tags.put("includeDependenciesReport", extension.includeDependenciesReport.get().toString())
      tags.put("includeSourceContext", extension.includeSourceContext.get().toString())
      tags.put(
        "additionalSourceDirsForSourceContext_set",
        extension.additionalSourceDirsForSourceContext.get().isNotEmpty().toString(),
      )
      // TODO PII?
      //            extension.projectName.orNull?.let { tags.put("projectName", it) }

      try {
        val android = project.extensions.findByType(CommonExtension::class.java)
        if (android != null) {
          tags.put(
            "coreLibraryDesugaring_enabled",
            android.compileOptions.isCoreLibraryDesugaringEnabled.toString(),
          )
          android.defaultConfig.minSdk?.let { tags.put("minSdk", it.toString()) }
        }
      } catch (_: Throwable) {
        // Android extensions may not be available (e.g. JVM plugin)
      }

      return tags
    }
  }
}

class SentryMinimalException(message: String) : RuntimeException(message) {
  override fun getStackTrace(): Array<StackTraceElement> {
    val superStackTrace = super.getStackTrace()
    return if (superStackTrace.isEmpty()) superStackTrace else arrayOf(superStackTrace[0])
  }
}

data class SentryTelemetryServiceParams(
  val sendTelemetry: Boolean,
  val dsn: String,
  val sentryOrganization: String?,
  val buildType: String,
  val extraTags: Map<String, String>,
  val isDebug: Boolean,
  val saas: Boolean? = null,
  val cliVersion: String? = null,
  val cliOrgProvider: Provider<String>? = null,
)