[DPP-686][Self-service error codes] Removing default error factories

ledger/error/src/main/scala/com/daml/error/definitions/LedgerApiErrors.scala

@@ -579,6 +579,13 @@ object LedgerApiErrors extends LedgerApiErrorGroup {
         ErrorCategory.SystemInternalAssumptionViolated,
       ) {
 
+    // TODO error codes: This is an internal error not related to the interpreter
+    case class CommandTrackerInternalError(
+        message: String
+    )(implicit
+        loggingContext: ContextualizedErrorLogger
+    ) extends LoggingTransactionErrorImpl(cause = message)
+
     case class PackageSelfConsistency(
         err: LfError.Package.SelfConsistency
     )(implicit

ledger/error/src/main/scala/com/daml/error/definitions/RejectionGenerators.scala

@@ -3,16 +3,16 @@
 
 package com.daml.error.definitions
 
-import com.daml.error.{BaseError, ErrorCause, ErrorCode, ContextualizedErrorLogger}
+import com.daml.error.{BaseError, ContextualizedErrorLogger, ErrorCause, ErrorCode}
 import com.daml.ledger.participant.state
 import com.daml.lf.engine.Error.{Interpretation, Package, Preprocessing, Validation}
+import com.daml.lf.engine.{Error => LfError}
+import com.daml.lf.interpretation.{Error => LfInterpretationError}
 import io.grpc.Status.Code
 import io.grpc.StatusRuntimeException
 import io.grpc.protobuf.StatusProto
 
 import scala.util.{Failure, Success, Try}
-import com.daml.lf.engine.{Error => LfError}
-import com.daml.lf.interpretation.{Error => LfInterpretationError}
 
 class RejectionGenerators(conformanceMode: Boolean) {
   private val adjustErrors = Map(

ledger/indexer-benchmark/BUILD.bazel

@@ -29,6 +29,7 @@ da_scala_library(
     deps = [
         "//daml-lf/data",
         "//language-support/scala/bindings",
+        "//ledger/ledger-api-common",
         "//ledger/ledger-api-health",
         "//ledger/ledger-configuration",
         "//ledger/ledger-offset",

ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/ErrorFactories.scala

@@ -402,6 +402,20 @@ class ErrorFactories private (errorCodesVersionSwitcher: ErrorCodesVersionSwitch
       v2 = LedgerApiErrors.ServiceNotRunning.Reject().asGrpcError,
     )
 
+  def trackerFailure(msg: String)(implicit
+      contextualizedErrorLogger: ContextualizedErrorLogger
+  ): StatusRuntimeException =
+    errorCodesVersionSwitcher.choose(
+      v1 = {
+        val builder = Status
+          .newBuilder()
+          .setCode(Code.INTERNAL.value())
+          .setMessage(msg)
+        grpcError(builder.build())
+      },
+      v2 = LedgerApiErrors.InternalError.CommandTrackerInternalError(msg).asGrpcError,
+    )
+
   /** Transforms Protobuf [[Status]] objects, possibly including metadata packed as [[ErrorInfo]] objects,
     * into exceptions with metadata in the trailers.
     *
@@ -427,11 +441,7 @@ class ErrorFactories private (errorCodesVersionSwitcher: ErrorCodesVersionSwitch
   }
 }
 
-/** Object exposing the legacy error factories.
-  * TODO error codes: Remove default implementation once all Ledger API services
-  *                   output versioned error codes.
-  */
-object ErrorFactories extends ErrorFactories(new ErrorCodesVersionSwitcher(false)) {
+object ErrorFactories {
   def apply(errorCodesVersionSwitcher: ErrorCodesVersionSwitcher): ErrorFactories =
     new ErrorFactories(errorCodesVersionSwitcher)
 

ledger/ledger-api-common/src/test/suite/scala/com/digitalasset/platform/server/api/validation/ErrorFactoriesSpec.scala

@@ -18,13 +18,18 @@ import com.google.rpc._
 import io.grpc.Status.Code
 import io.grpc.StatusRuntimeException
 import io.grpc.protobuf.StatusProto
+import org.mockito.MockitoSugar
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.prop.TableDrivenPropertyChecks
 import org.scalatest.wordspec.AnyWordSpec
 
 import scala.jdk.CollectionConverters._
 
-class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPropertyChecks {
+class ErrorFactoriesSpec
+    extends AnyWordSpec
+    with Matchers
+    with TableDrivenPropertyChecks
+    with MockitoSugar {
   private val correlationId = "trace-id"
   private val logger = ContextualizedLogger.get(getClass)
   private val loggingContext = LoggingContext.ForTesting
@@ -35,6 +40,8 @@ class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPrope
   private val DefaultTraceIdRequestInfo: ErrorDetails.RequestInfoDetail =
     ErrorDetails.RequestInfoDetail("trace-id")
 
+  val tested = ErrorFactories(mock[ErrorCodesVersionSwitcher])
+
   "ErrorFactories" should {
     "return malformedPackageId" in {
       assertVersionedError(
@@ -246,7 +253,7 @@ class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPrope
       )
 
       forEvery(testCases) { (definiteAnswer, expectedDetails) =>
-        val exception = aborted("my message", definiteAnswer)
+        val exception = tested.aborted("my message", definiteAnswer)
         val status = StatusProto.fromThrowable(exception)
         status.getCode shouldBe Code.ABORTED.value()
         status.getMessage shouldBe "my message"
@@ -303,7 +310,7 @@ class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPrope
     }
 
     "fail on creating a ledgerIdMismatch error due to a wrong definite answer" in {
-      an[IllegalArgumentException] should be thrownBy ledgerIdMismatch(
+      an[IllegalArgumentException] should be thrownBy tested.ledgerIdMismatch(
         LedgerId("expected"),
         LedgerId("received"),
         definiteAnswer = Some(true),
@@ -324,6 +331,21 @@ class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPrope
       )
     }
 
+    "return a trackerFailure error" in {
+      assertVersionedError(_.trackerFailure("message123"))(
+        v1_code = Code.INTERNAL,
+        v1_message = "message123",
+        v1_details = Seq.empty,
+        v2_code = Code.INTERNAL,
+        v2_message =
+          s"An error occurred. Please contact the operator and inquire about the request trace-id",
+        v2_details = Seq[ErrorDetails.ErrorDetail](
+          ErrorDetails.ErrorInfoDetail("LEDGER_API_INTERNAL_ERROR"),
+          DefaultTraceIdRequestInfo,
+        ),
+      )
+    }
+
     "return an offsetAfterLedgerEnd error" in {
       assertVersionedError(_.offsetAfterLedgerEnd("my message"))(
         v1_code = Code.OUT_OF_RANGE,
@@ -447,7 +469,7 @@ class ErrorFactoriesSpec extends AnyWordSpec with Matchers with TableDrivenPrope
 
     "should create an ApiException without the stack trace" in {
       val status = Status.newBuilder().setCode(Code.INTERNAL.value()).build()
-      val exception = grpcError(status)
+      val exception = tested.grpcError(status)
       exception.getStackTrace shouldBe Array.empty
     }
   }

ledger/participant-integration-api/BUILD.bazel

@@ -67,7 +67,6 @@ compile_deps = [
     "//libs-scala/scala-utils",
     "//libs-scala/timer-utils",
     "//libs-scala/nameof",
-    "@maven//:com_google_api_grpc_proto_google_common_protos",
     "@maven//:com_google_guava_guava",
     "@maven//:com_zaxxer_HikariCP",
     "@maven//:io_dropwizard_metrics_metrics_core",
@@ -162,6 +161,7 @@ da_scala_library(
         "@maven//:org_scalatest_scalatest_flatspec",
         "@maven//:org_scalatest_scalatest_matchers_core",
         "@maven//:org_scalatest_scalatest_shouldmatchers",
+        "@maven//:org_mockito_mockito_scala",
     ],
     scala_runtime_deps = [
         "@maven//:com_typesafe_akka_akka_slf4j",
@@ -211,6 +211,7 @@ da_scala_library(
         "@maven//:io_netty_netty_common",
         "@maven//:io_netty_netty_handler",
         "@maven//:io_netty_netty_transport",
+        "@maven//:org_mockito_mockito_core",
         "@maven//:org_scalatest_scalatest_compatible",
     ],
 )
@@ -353,6 +354,7 @@ da_scala_test_suite(
         "@maven//:org_scalatest_scalatest_matchers_core",
         "@maven//:org_scalatest_scalatest_shouldmatchers",
         "@maven//:org_scalatest_scalatest_wordspec",
+        "@maven//:org_mockito_mockito_scala",
     ],
     tags = [] if oracle_testing else ["manual"],
     runtime_deps = [

ledger/participant-integration-api/src/main/scala/platform/apiserver/StandaloneApiServer.scala

@@ -90,6 +90,7 @@ final class StandaloneApiServer(
           enableMutableContractStateCache = config.enableMutableContractStateCache,
           maxTransactionsInMemoryFanOutBufferSize = config.maxTransactionsInMemoryFanOutBufferSize,
           enableInMemoryFanOutForLedgerApi = config.enableInMemoryFanOutForLedgerApi,
+          enableSelfServiceErrorCodes = config.enableSelfServiceErrorCodes,
         )
         .map(index => new SpannedIndexService(new TimedIndexService(index, metrics)))
       errorCodesVersionSwitcher = new ErrorCodesVersionSwitcher(

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiCommandService.scala

@@ -192,7 +192,13 @@ private[apiserver] object ApiCommandService {
     val submissionTracker = new TrackerMap.SelfCleaning(
       configuration.trackerRetentionPeriod,
       Tracking.getTrackerKey,
-      Tracking.newTracker(configuration, submissionFlow, completionServices, metrics),
+      Tracking.newTracker(
+        configuration,
+        submissionFlow,
+        completionServices,
+        metrics,
+        ErrorFactories(errorCodesVersionSwitcher),
+      ),
       trackerCleanupInterval,
     )
     new GrpcCommandService(
@@ -238,6 +244,7 @@ private[apiserver] object ApiCommandService {
         submissionFlow: SubmissionFlow,
         completionServices: CompletionServices,
         metrics: Metrics,
+        errorFactories: ErrorFactories,
     )(
         key: Tracking.Key
     )(implicit
@@ -285,6 +292,7 @@ private[apiserver] object ApiCommandService {
           capacityCounter = metrics.daml.commands.inputBufferCapacity,
           lengthCounter = metrics.daml.commands.inputBufferLength,
           delayTimer = metrics.daml.commands.inputBufferDelay,
+          errorFactories = errorFactories,
         )
       }
     }

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiConfigManagementService.scala

@@ -152,6 +152,7 @@ private[apiserver] final class ApiConfigManagementService private (
               errorFactories,
             ),
             timeToLive = JDuration.ofMillis(params.timeToLive.toMillis),
+            errorFactories = errorFactories,
           )
           entry <- synchronousResponse.submitAndWait(
             augmentedSubmissionId,

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPackageManagementService.scala

@@ -64,7 +64,6 @@ private[apiserver] final class ApiPackageManagementService private (
     new DamlContextualizedErrorLogger(logger, loggingContext, None)
 
   private val errorFactories = ErrorFactories(errorCodesVersionSwitcher)
-
   private val synchronousResponse = new SynchronousResponse(
     new SynchronousResponseStrategy(
       transactionsService,
@@ -73,6 +72,7 @@ private[apiserver] final class ApiPackageManagementService private (
       errorFactories,
     ),
     timeToLive = managementServiceTimeout,
+    errorFactories = errorFactories,
   )
 
   override def close(): Unit = ()

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPartyManagementService.scala

@@ -62,6 +62,7 @@ private[apiserver] final class ApiPartyManagementService private (
       errorFactories,
     ),
     timeToLive = managementServiceTimeout,
+    errorFactories = errorFactories,
   )
 
   override def close(): Unit = ()

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/SynchronousResponse.scala

@@ -27,6 +27,7 @@ import scala.concurrent.{ExecutionContext, Future, TimeoutException}
 class SynchronousResponse[Input, Entry, AcceptedEntry](
     strategy: SynchronousResponse.Strategy[Input, Entry, AcceptedEntry],
     timeToLive: Duration,
+    errorFactories: ErrorFactories,
 ) {
 
   def submitAndWait(submissionId: Ref.SubmissionId, input: Input)(implicit
@@ -52,7 +53,7 @@ class SynchronousResponse[Input, Entry, AcceptedEntry](
             .runWith(Sink.head)
             .recoverWith { case _: TimeoutException =>
               Future.failed(
-                ErrorFactories.aborted("Request timed out", definiteAnswer = Some(false))
+                errorFactories.aborted("Request timed out", definiteAnswer = Some(false))
               )
             }
             .flatten

ledger/participant-integration-api/src/main/scala/platform/apiserver/services/tracking/QueueBackedTracker.scala

@@ -8,6 +8,7 @@ import akka.stream.{Materializer, OverflowStrategy, QueueOfferResult}
 import akka.{Done, NotUsed}
 import com.codahale.metrics.{Counter, Timer}
 import com.daml.dec.DirectExecutionContext
+import com.daml.error.DamlContextualizedErrorLogger
 import com.daml.ledger.client.services.commands.CommandSubmission
 import com.daml.ledger.client.services.commands.CommandTrackerFlow.Materialized
 import com.daml.ledger.client.services.commands.tracker.CompletionResponse._
@@ -16,15 +17,14 @@ import com.daml.metrics.InstrumentedSource
 import com.daml.platform.apiserver.services.tracking.QueueBackedTracker._
 import com.daml.platform.server.api.validation.ErrorFactories
 import com.daml.util.Ctx
-import com.google.rpc.Status
-import io.grpc.Status.Code
 import io.grpc.{Status => GrpcStatus}
 
 import scala.concurrent.duration._
 import scala.concurrent.{Await, ExecutionContext, Future, Promise}
-import scala.util.{Failure, Success}
+import scala.util.{Failure, Success, Try}
 
 /** Tracks SubmitAndWaitRequests.
+  *
   * @param queue The input queue to the tracking flow.
   */
 private[services] final class QueueBackedTracker(
@@ -110,6 +110,7 @@ private[services] object QueueBackedTracker {
       capacityCounter: Counter,
       lengthCounter: Counter,
       delayTimer: Timer,
+      errorFactories: ErrorFactories,
   )(implicit materializer: Materializer, loggingContext: LoggingContext): QueueBackedTracker = {
     val ((queue, mat), done) = InstrumentedSource
       .queue[QueueInput](
@@ -147,19 +148,17 @@ private[services] object QueueBackedTracker {
       mat.trackingMat.onComplete(
         // no error expected here -- if there is one, we're at a total loss.
         // FIXME(mthvedt): we should shut down everything in this case.
-        _.get.values
-          .foreach(
-            _.failure(
-              ErrorFactories.grpcError(
-                Status
-                  .newBuilder()
-                  .setCode(Code.INTERNAL.value())
-                  .setMessage(promiseCancellationDescription)
-                  .build()
-              )
+        (aTry: Try[Map[_, Promise[_]]]) => {
+          val promises: Iterable[Promise[_]] = aTry.get.values
+          val errorLogger = new DamlContextualizedErrorLogger(logger, loggingContext, None)
+          promises.foreach(p =>
+            p.failure(
+              errorFactories.trackerFailure(msg = promiseCancellationDescription)(errorLogger)
             )
           )
+        }
       )(DirectExecutionContext)
+
     }(DirectExecutionContext)
 
     new QueueBackedTracker(queue, done)

ledger/participant-integration-api/src/main/scala/platform/index/JdbcIndex.scala

@@ -4,6 +4,7 @@
 package com.daml.platform.index
 
 import akka.stream.Materializer
+import com.daml.error.ErrorCodesVersionSwitcher
 import com.daml.ledger.api.domain.LedgerId
 import com.daml.ledger.participant.state.index.v2.IndexService
 import com.daml.ledger.resources.ResourceOwner
@@ -12,6 +13,7 @@ import com.daml.lf.engine.ValueEnricher
 import com.daml.logging.LoggingContext
 import com.daml.metrics.Metrics
 import com.daml.platform.configuration.ServerRole
+import com.daml.platform.server.api.validation.ErrorFactories
 import com.daml.platform.store.LfValueTranslationCache
 
 import scala.concurrent.ExecutionContext
@@ -36,6 +38,7 @@ private[platform] object JdbcIndex {
       enableMutableContractStateCache: Boolean,
       maxTransactionsInMemoryFanOutBufferSize: Long,
       enableInMemoryFanOutForLedgerApi: Boolean,
+      enableSelfServiceErrorCodes: Boolean,
   )(implicit mat: Materializer, loggingContext: LoggingContext): ResourceOwner[IndexService] =
     new ReadOnlySqlLedger.Owner(
       serverRole = serverRole,
@@ -55,7 +58,12 @@ private[platform] object JdbcIndex {
       enableInMemoryFanOutForLedgerApi = enableInMemoryFanOutForLedgerApi,
       participantId = participantId,
       maxTransactionsInMemoryFanOutBufferSize = maxTransactionsInMemoryFanOutBufferSize,
+      errorFactories = ErrorFactories(new ErrorCodesVersionSwitcher(enableSelfServiceErrorCodes)),
     ).map { ledger =>
-      new LedgerBackedIndexService(MeteredReadOnlyLedger(ledger, metrics), participantId)
+      new LedgerBackedIndexService(
+        MeteredReadOnlyLedger(ledger, metrics),
+        participantId,
+        errorFactories = ErrorFactories(new ErrorCodesVersionSwitcher(enableSelfServiceErrorCodes)),
+      )
     }
 }

ledger/participant-integration-api/src/main/scala/platform/index/LedgerBackedIndexService.scala

@@ -53,6 +53,7 @@ import scala.concurrent.Future
 private[platform] final class LedgerBackedIndexService(
     ledger: ReadOnlyLedger,
     participantId: Ref.ParticipantId,
+    errorFactories: ErrorFactories,
 ) extends IndexService {
   private val logger = ContextualizedLogger.get(getClass)
 
@@ -144,7 +145,7 @@ private[platform] final class LedgerBackedIndexService(
           case Some(end) if begin > end =>
             Source.failed(
               // TODO error codes: Replace with LedgerApiErrors.ReadErrors.RequestedOffsetAfterLedgerEnd
-              ErrorFactories.invalidArgument(None)(
+              errorFactories.invalidArgument(None)(
                 s"End offset ${end.toApiString} is before Begin offset ${begin.toApiString}."
               )(new DamlContextualizedErrorLogger(logger, loggingContext, None))
             )