Log ledger api validation failures at info level (#10080)

* CHANGELOG_BEGIN Log ledger api validation failures at info level CHANGELOG_END * log validation failures in Api*Service family of classes * address review comments
2024-09-20 01:07:18 +03:00 · 2021-06-23 15:31:48 +02:00 · 2021-06-23 15:31:48 +02:00 · db60d15b5e
commit db60d15b5e
parent f0dc025ac9
17 changed files with 124 additions and 111 deletions
--- a/ledger/ledger-api-common/BUILD.bazel
+++ b/ledger/ledger-api-common/BUILD.bazel
@ -39,6 +39,7 @@ da_scala_library(
        "//ledger/ledger-resources",
        "//ledger/metrics",
        "//libs-scala/concurrent",
+        "//libs-scala/contextualized-logging",
        "//libs-scala/resources",
        "//libs-scala/resources-akka",
        "//libs-scala/resources-grpc",
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/ValidationLogger.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/ValidationLogger.scala
@ -0,0 +1,24 @@
+// Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.platform.server.api
+
+import com.daml.logging.{ContextualizedLogger, LoggingContext}
+import org.slf4j.Logger
+
+object ValidationLogger {
+  def logFailure[Request](request: Request, t: Throwable)(implicit logger: Logger): Throwable = {
+    logger.debug(s"Request validation failed for $request. Message: ${t.getMessage}")
+    logger.info(t.getMessage)
+    t
+  }
+
+  def logFailureWithContext[Request](request: Request, t: Throwable)(implicit
+      logger: ContextualizedLogger,
+      loggingContext: LoggingContext,
+  ): Throwable = {
+    logger.debug(s"Request validation failed for $request. Message: ${t.getMessage}")
+    logger.info(t.getMessage)
+    t
+  }
+}
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandCompletionService.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandCompletionService.scala
@ -14,7 +14,9 @@ import com.daml.ledger.api.messages.command.completion.{
 import com.daml.ledger.api.v1.command_completion_service._
 import com.daml.ledger.api.v1.ledger_offset.LedgerOffset
 import com.daml.ledger.api.validation.{CompletionServiceRequestValidator, PartyNameChecker}
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.services.domain.CommandCompletionService
+import org.slf4j.{Logger, LoggerFactory}

 import scala.concurrent.{ExecutionContext, Future}

@ -44,6 +46,7 @@ class GrpcCommandCompletionService(
 ) extends CommandCompletionServiceAkkaGrpc {

  private val validator = new CompletionServiceRequestValidator(ledgerId, partyNameChecker)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  override def completionStreamSource(
      request: CompletionStreamRequest
@ -52,7 +55,7 @@ class GrpcCommandCompletionService(
      validator
        .validateCompletionStreamRequest(request, ledgerEnd, service.offsetOrdering)
        .fold(
-          Source.failed[CompletionStreamResponse],
+          t => Source.failed[CompletionStreamResponse](ValidationLogger.logFailure(request, t)),
          GrpcCommandCompletionService.fillInWithDefaults _ andThen service.completionStreamSource,
        )
    }
@ -62,7 +65,7 @@ class GrpcCommandCompletionService(
    validator
      .validateCompletionEndRequest(request)
      .fold(
-        Future.failed[CompletionEndResponse],
+        t => Future.failed[CompletionEndResponse](ValidationLogger.logFailure(request, t)),
        req =>
          service
            .getLedgerEnd(req.ledgerId)
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandService.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandService.scala
@ -10,7 +10,7 @@ import com.daml.ledger.api.v1.command_service.CommandServiceGrpc.CommandService
 import com.daml.ledger.api.v1.command_service._
 import com.daml.ledger.api.validation.{CommandsValidator, SubmitAndWaitRequestValidator}
 import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
+import com.daml.platform.server.api.{ProxyCloseable, ValidationLogger}
 import com.google.protobuf.empty.Empty
 import io.grpc.ServerServiceDefinition
 import org.slf4j.{Logger, LoggerFactory}
@ -28,7 +28,7 @@ class GrpcCommandService(
    with GrpcApiService
    with ProxyCloseable {

-  protected val logger: Logger = LoggerFactory.getLogger(CommandService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  private[this] val validator =
    new SubmitAndWaitRequestValidator(new CommandsValidator(ledgerId))
@ -36,28 +36,40 @@ class GrpcCommandService(
  override def submitAndWait(request: SubmitAndWaitRequest): Future[Empty] =
    validator
      .validate(request, currentLedgerTime(), currentUtcTime(), maxDeduplicationTime())
-      .fold(Future.failed, _ => service.submitAndWait(request))
+      .fold(
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
+        _ => service.submitAndWait(request),
+      )

  override def submitAndWaitForTransactionId(
      request: SubmitAndWaitRequest
  ): Future[SubmitAndWaitForTransactionIdResponse] =
    validator
      .validate(request, currentLedgerTime(), currentUtcTime(), maxDeduplicationTime())
-      .fold(Future.failed, _ => service.submitAndWaitForTransactionId(request))
+      .fold(
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
+        _ => service.submitAndWaitForTransactionId(request),
+      )

  override def submitAndWaitForTransaction(
      request: SubmitAndWaitRequest
  ): Future[SubmitAndWaitForTransactionResponse] =
    validator
      .validate(request, currentLedgerTime(), currentUtcTime(), maxDeduplicationTime())
-      .fold(Future.failed, _ => service.submitAndWaitForTransaction(request))
+      .fold(
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
+        _ => service.submitAndWaitForTransaction(request),
+      )

  override def submitAndWaitForTransactionTree(
      request: SubmitAndWaitRequest
  ): Future[SubmitAndWaitForTransactionTreeResponse] =
    validator
      .validate(request, currentLedgerTime(), currentUtcTime(), maxDeduplicationTime())
-      .fold(Future.failed, _ => service.submitAndWaitForTransactionTree(request))
+      .fold(
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
+        _ => service.submitAndWaitForTransactionTree(request),
+      )

  override def bindService(): ServerServiceDefinition =
    CommandServiceGrpc.bindService(this, executionContext)
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandSubmissionService.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcCommandSubmissionService.scala
@ -16,7 +16,7 @@ import com.daml.ledger.api.v1.command_submission_service.{
 import com.daml.ledger.api.validation.{CommandsValidator, SubmitRequestValidator}
 import com.daml.metrics.{Metrics, Timed}
 import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
+import com.daml.platform.server.api.{ProxyCloseable, ValidationLogger}
 import com.daml.platform.server.api.services.domain.CommandSubmissionService
 import com.daml.telemetry.{DefaultTelemetry, SpanAttribute, TelemetryContext}
 import com.google.protobuf.empty.Empty
@ -37,7 +37,7 @@ class GrpcCommandSubmissionService(
    with ProxyCloseable
    with GrpcApiService {

-  protected val logger: Logger = LoggerFactory.getLogger(ApiCommandSubmissionService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  private val validator = new SubmitRequestValidator(new CommandsValidator(ledgerId))

@ -59,7 +59,10 @@ class GrpcCommandSubmissionService(
          validator
            .validate(request, currentLedgerTime(), currentUtcTime(), maxDeduplicationTime()),
        )
-        .fold(Future.failed, service.submit(_).map(_ => Empty.defaultInstance)),
+        .fold(
+          t => Future.failed(ValidationLogger.logFailure(request, t)),
+          service.submit(_).map(_ => Empty.defaultInstance),
+        ),
    )
  }

--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcTransactionService.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/services/grpc/GrpcTransactionService.scala
@ -9,13 +9,11 @@ import akka.stream.scaladsl.Source
 import com.daml.grpc.adapter.ExecutionSequencerFactory
 import com.daml.ledger.api.domain.LedgerId
 import com.daml.ledger.api.v1.ledger_offset.LedgerOffset
-import com.daml.ledger.api.v1.transaction_service.TransactionServiceGrpc.{
-  TransactionService => ApiTransactionService
-}
 import com.daml.ledger.api.v1.transaction_service._
 import com.daml.ledger.api.validation.TransactionServiceRequestValidator.Result
 import com.daml.ledger.api.validation.{PartyNameChecker, TransactionServiceRequestValidator}
 import com.daml.platform.api.grpc.GrpcApiService
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.services.domain.TransactionService
 import com.daml.platform.server.api.validation.{ErrorFactories, FieldValidations}
 import io.grpc.ServerServiceDefinition
@ -36,7 +34,7 @@ final class GrpcTransactionService(
    with ErrorFactories
    with FieldValidations {

-  protected val logger: Logger = LoggerFactory.getLogger(ApiTransactionService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  private val validator =
    new TransactionServiceRequestValidator(ledgerId, partyNameChecker)
@ -49,10 +47,7 @@ final class GrpcTransactionService(
      val validation = validator.validate(request, ledgerEnd, service.offsetOrdering)

      validation.fold(
-        { t =>
-          logger.debug("Request validation failed for {}. Message: {}", request: Any, t.getMessage)
-          Source.failed(t)
-        },
+        t => Source.failed(ValidationLogger.logFailure(request, t)),
        req =>
          if (req.filter.filtersByParty.isEmpty) Source.empty
          else service.getTransactions(req),
@ -68,10 +63,7 @@ final class GrpcTransactionService(
      val validation = validator.validateTree(request, ledgerEnd, service.offsetOrdering)

      validation.fold(
-        { t =>
-          logger.debug("Request validation failed for {}. Message: {}", request: Any, t.getMessage)
-          Source.failed(t)
-        },
+        t => Source.failed(ValidationLogger.logFailure(request, t)),
        req => {
          if (req.parties.isEmpty) Source.empty
          else service.getTransactionTrees(req)
@ -81,11 +73,11 @@ final class GrpcTransactionService(
  }

  private def getSingleTransaction[Request, DomainRequest, DomainTx, Response](
-      req: Request,
+      request: Request,
      validate: Request => Result[DomainRequest],
      fetch: DomainRequest => Future[Response],
  ): Future[Response] =
-    validate(req).fold(Future.failed, fetch(_))
+    validate(request).fold(t => Future.failed(ValidationLogger.logFailure(request, t)), fetch(_))

  override def getTransactionByEventId(
      request: GetTransactionByEventIdRequest
@ -131,7 +123,7 @@ final class GrpcTransactionService(
    val validation = validator.validateLedgerEnd(request)

    validation.fold(
-      Future.failed,
+      t => Future.failed(ValidationLogger.logFailure(request, t)),
      _ =>
        service
          .getLedgerEnd(request.ledgerId)
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/ActiveContractsServiceValidation.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/ActiveContractsServiceValidation.scala
@ -11,7 +11,7 @@ import com.daml.ledger.api.v1.active_contracts_service.{
  GetActiveContractsResponse,
 }
 import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
+import com.daml.platform.server.api.{ProxyCloseable, ValidationLogger}
 import io.grpc.ServerServiceDefinition
 import io.grpc.stub.StreamObserver
 import org.slf4j.{Logger, LoggerFactory}
@ -27,14 +27,17 @@ class ActiveContractsServiceValidation(
    with GrpcApiService
    with FieldValidations {

-  protected val logger: Logger = LoggerFactory.getLogger(ActiveContractsService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  override def getActiveContracts(
      request: GetActiveContractsRequest,
      responseObserver: StreamObserver[GetActiveContractsResponse],
  ): Unit = {
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
-      .fold(responseObserver.onError, _ => service.getActiveContracts(request, responseObserver))
+      .fold(
+        t => responseObserver.onError(ValidationLogger.logFailure(request, t)),
+        _ => service.getActiveContracts(request, responseObserver),
+      )
  }
  override def bindService(): ServerServiceDefinition =
    ActiveContractsServiceGrpc.bindService(this, executionContext)
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/CommandCompletionServiceValidation.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/CommandCompletionServiceValidation.scala
@ -1,53 +0,0 @@
-// Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package com.daml.platform.server.api.validation
-
-import com.daml.ledger.api.domain.LedgerId
-import com.daml.ledger.api.v1.command_completion_service.CommandCompletionServiceGrpc.CommandCompletionService
-import com.daml.ledger.api.v1.command_completion_service._
-import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
-import io.grpc.ServerServiceDefinition
-import io.grpc.stub.StreamObserver
-import org.slf4j.{Logger, LoggerFactory}
-
-import scala.concurrent.{ExecutionContext, Future}
-
-//TODO: this class is only needed by DamlOnXCommandCompletionService.scala. Must be deleted once that's gone!
-class CommandCompletionServiceValidation(
-    val service: CommandCompletionService with AutoCloseable,
-    val ledgerId: LedgerId,
-)(implicit executionContext: ExecutionContext)
-    extends CommandCompletionService
-    with FieldValidations
-    with GrpcApiService
-    with ProxyCloseable
-    with ErrorFactories {
-
-  protected val logger: Logger = LoggerFactory.getLogger(CommandCompletionService.getClass)
-
-  override def completionStream(
-      request: CompletionStreamRequest,
-      responseObserver: StreamObserver[CompletionStreamResponse],
-  ): Unit = {
-    val validation = for {
-      _ <- matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
-      _ <- requireNonEmptyString(request.applicationId, "application_id")
-      _ <- requireNonEmpty(request.parties, "parties")
-    } yield request
-
-    validation.fold(
-      exception => responseObserver.onError(exception),
-      value => service.completionStream(value, responseObserver),
-    )
-  }
-
-  override def completionEnd(request: CompletionEndRequest): Future[CompletionEndResponse] = {
-    matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
-      .fold(Future.failed, _ => service.completionEnd(request))
-  }
-
-  override def bindService(): ServerServiceDefinition =
-    CommandCompletionServiceGrpc.bindService(this, executionContext)
-}
--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/LedgerConfigurationServiceValidation.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/LedgerConfigurationServiceValidation.scala
@ -11,7 +11,7 @@ import com.daml.ledger.api.v1.ledger_configuration_service.{
  LedgerConfigurationServiceGrpc,
 }
 import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
+import com.daml.platform.server.api.{ProxyCloseable, ValidationLogger}
 import io.grpc.ServerServiceDefinition
 import io.grpc.stub.StreamObserver
 import org.slf4j.{Logger, LoggerFactory}
@ -27,14 +27,14 @@ class LedgerConfigurationServiceValidation(
    with GrpcApiService
    with FieldValidations {

-  protected val logger: Logger = LoggerFactory.getLogger(LedgerConfigurationService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  override def getLedgerConfiguration(
      request: GetLedgerConfigurationRequest,
      responseObserver: StreamObserver[GetLedgerConfigurationResponse],
  ): Unit =
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId)).fold(
-      t => responseObserver.onError(t),
+      t => responseObserver.onError(ValidationLogger.logFailure(request, t)),
      _ => service.getLedgerConfiguration(request, responseObserver),
    )

--- a/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/PackageServiceValidation.scala
+++ b/ledger/ledger-api-common/src/main/scala/com/digitalasset/platform/server/api/validation/PackageServiceValidation.scala
@ -7,7 +7,7 @@ import com.daml.ledger.api.domain.LedgerId
 import com.daml.ledger.api.v1.package_service.PackageServiceGrpc.PackageService
 import com.daml.ledger.api.v1.package_service._
 import com.daml.platform.api.grpc.GrpcApiService
-import com.daml.platform.server.api.ProxyCloseable
+import com.daml.platform.server.api.{ProxyCloseable, ValidationLogger}
 import io.grpc.ServerServiceDefinition
 import org.slf4j.{Logger, LoggerFactory}

@ -23,13 +23,13 @@ class PackageServiceValidation(
    with GrpcApiService
    with FieldValidations {

-  protected val logger: Logger = LoggerFactory.getLogger(PackageService.getClass)
+  protected implicit val logger: Logger = LoggerFactory.getLogger(service.getClass)

  override def listPackages(request: ListPackagesRequest): Future[ListPackagesResponse] =
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
      .map(const(request))
      .fold(
-        Future.failed,
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
        service.listPackages,
      )

@ -37,7 +37,7 @@ class PackageServiceValidation(
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
      .map(const(request))
      .fold(
-        Future.failed,
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
        service.getPackage,
      )

@ -47,7 +47,7 @@ class PackageServiceValidation(
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId))
      .map(const(request))
      .fold(
-        Future.failed,
+        t => Future.failed(ValidationLogger.logFailure(request, t)),
        service.getPackageStatus,
      )
  override def bindService(): ServerServiceDefinition =
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiActiveContractsService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiActiveContractsService.scala
@ -16,6 +16,7 @@ import com.daml.logging.LoggingContext.withEnrichedLoggingContext
 import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.metrics.Metrics
 import com.daml.platform.api.grpc.GrpcApiService
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.ActiveContractsServiceValidation
 import io.grpc.{BindableService, ServerServiceDefinition}

@ -32,7 +33,7 @@ private[apiserver] final class ApiActiveContractsService private (
 ) extends ActiveContractsServiceAkkaGrpc
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  override protected def getActiveContractsSource(
      request: GetActiveContractsRequest
@ -42,7 +43,10 @@ private[apiserver] final class ApiActiveContractsService private (
        logger.info(s"Received request for active contracts: $request")
        TransactionFilterValidator
          .validate(request.getFilter)
-          .fold(Source.failed, backend.getActiveContracts(_, request.verbose))
+          .fold(
+            t => Source.failed(ValidationLogger.logFailureWithContext(request, t)),
+            backend.getActiveContracts(_, request.verbose),
+          )
          .via(logger.logErrorsOnStream)
          .via(StreamMetrics.countElements(metrics.daml.lapi.streams.acs))
    }
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiPackageService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiPackageService.scala
@ -16,6 +16,7 @@ import com.daml.lf.data.Ref
 import com.daml.logging.LoggingContext.withEnrichedLoggingContext
 import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.platform.api.grpc.GrpcApiService
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.PackageServiceValidation
 import io.grpc.{BindableService, ServerServiceDefinition, Status}

@ -27,7 +28,7 @@ private[apiserver] final class ApiPackageService private (
    extends PackageService
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  override def bindService(): ServerServiceDefinition =
    PackageServiceGrpc.bindService(this, executionContext)
@ -45,7 +46,7 @@ private[apiserver] final class ApiPackageService private (
  override def getPackage(request: GetPackageRequest): Future[GetPackageResponse] =
    withEnrichedLoggingContext("packageId" -> request.packageId) { implicit loggingContext =>
      logger.info(s"Received request for a package: $request")
-      withValidatedPackageId(request.packageId) { packageId =>
+      withValidatedPackageId(request.packageId, request) { packageId =>
        backend
          .getLfArchive(packageId)
          .flatMap(
@ -62,7 +63,7 @@ private[apiserver] final class ApiPackageService private (
  ): Future[GetPackageStatusResponse] =
    withEnrichedLoggingContext("packageId" -> request.packageId) { implicit loggingContext =>
      logger.info(s"Received request for a package status: $request")
-      withValidatedPackageId(request.packageId) { packageId =>
+      withValidatedPackageId(request.packageId, request) { packageId =>
        backend
          .listLfPackages()
          .map { packages =>
@ -77,15 +78,20 @@ private[apiserver] final class ApiPackageService private (
      }
    }

-  private def withValidatedPackageId[T](packageId: String)(block: Ref.PackageId => Future[T]) =
+  private def withValidatedPackageId[T, R](packageId: String, request: R)(
+      block: Ref.PackageId => Future[T]
+  ) =
    Ref.PackageId
      .fromString(packageId)
      .fold(
        error =>
          Future.failed[T](
-            Status.INVALID_ARGUMENT
-              .withDescription(error)
-              .asRuntimeException()
+            ValidationLogger.logFailureWithContext(
+              request,
+              Status.INVALID_ARGUMENT
+                .withDescription(error)
+                .asRuntimeException(),
+            )
          ),
        pId => block(pId),
      )
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiTimeService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiTimeService.scala
@ -17,6 +17,7 @@ import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.platform.akkastreams.dispatcher.SignalDispatcher
 import com.daml.platform.api.grpc.GrpcApiService
 import com.daml.platform.apiserver.TimeServiceBackend
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.FieldValidations
 import com.google.protobuf.empty.Empty
 import io.grpc.{ServerServiceDefinition, Status, StatusRuntimeException}
@ -37,7 +38,7 @@ private[apiserver] final class ApiTimeService private (
    with FieldValidations
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  logger.debug(
    s"${getClass.getSimpleName} initialized with ledger ID ${ledgerId.unwrap}, start time ${backend.getCurrentTime}"
@ -47,7 +48,7 @@ private[apiserver] final class ApiTimeService private (

  override protected def getTimeSource(request: GetTimeRequest): Source[GetTimeResponse, NotUsed] =
    matchLedgerId(ledgerId)(LedgerId(request.ledgerId)).fold(
-      Source.failed,
+      t => Source.failed(ValidationLogger.logFailureWithContext(request, t)),
      { ledgerId =>
        logger.info(s"Received request for time with ledger ID $ledgerId")
        dispatcher
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiConfigManagementService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiConfigManagementService.scala
@ -27,7 +27,7 @@ import com.daml.platform.api.grpc.GrpcApiService
 import com.daml.platform.apiserver.services.admin.ApiConfigManagementService._
 import com.daml.platform.apiserver.services.logging
 import com.daml.platform.configuration.LedgerConfiguration
-import com.daml.platform.server.api.validation
+import com.daml.platform.server.api.{ValidationLogger, validation}
 import com.daml.platform.server.api.validation.ErrorFactories
 import com.daml.telemetry.{DefaultTelemetry, TelemetryContext}
 import io.grpc.{ServerServiceDefinition, StatusRuntimeException}
@ -49,7 +49,7 @@ private[apiserver] final class ApiConfigManagementService private (
 ) extends ConfigManagementService
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  private val defaultConfigResponse = configToResponse(
    ledgerConfiguration.initialConfiguration.copy(generation = LedgerConfiguration.NoGeneration)
@ -92,7 +92,10 @@ private[apiserver] final class ApiConfigManagementService private (

        val response = for {
          // Validate and convert the request parameters
-          params <- validateParameters(request).fold(Future.failed(_), Future.successful)
+          params <- validateParameters(request).fold(
+            t => Future.failed(ValidationLogger.logFailureWithContext(request, t)),
+            Future.successful,
+          )

          // Lookup latest configuration to check generation and to extend it with the new time model.
          optConfigAndOffset <- index.lookupConfiguration()
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPackageManagementService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPackageManagementService.scala
@ -26,6 +26,7 @@ import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.platform.api.grpc.GrpcApiService
 import com.daml.platform.apiserver.services.admin.ApiPackageManagementService._
 import com.daml.platform.apiserver.services.logging
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.ErrorFactories
 import com.daml.telemetry.{DefaultTelemetry, TelemetryContext}
 import com.google.protobuf.timestamp.Timestamp
@ -49,7 +50,7 @@ private[apiserver] final class ApiPackageManagementService private (
 ) extends PackageManagementService
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  private val synchronousResponse = new SynchronousResponse(
    new SynchronousResponseStrategy(
@ -113,7 +114,11 @@ private[apiserver] final class ApiPackageManagementService private (

        val response = for {
          dar <- decodeAndValidate(darInputStream).fold(
-            err => Future.failed(ErrorFactories.invalidArgument(err.getMessage)),
+            err =>
+              Future.failed(
+                ValidationLogger
+                  .logFailureWithContext(request, ErrorFactories.invalidArgument(err.getMessage))
+              ),
            Future.successful,
          )
          _ <- synchronousResponse.submitAndWait(submissionId, dar)
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiParticipantPruningService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiParticipantPruningService.scala
@ -22,6 +22,7 @@ import com.daml.platform.apiserver.services.logging
 import com.daml.platform.ApiOffset
 import com.daml.platform.ApiOffset.ApiOffsetConverter
 import com.daml.platform.api.grpc.GrpcApiService
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.ErrorFactories
 import io.grpc.{ServerServiceDefinition, StatusRuntimeException}

@ -35,7 +36,7 @@ final class ApiParticipantPruningService private (
    extends ParticipantPruningServiceGrpc.ParticipantPruningService
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  override def bindService(): ServerServiceDefinition =
    ParticipantPruningServiceGrpc.bindService(this, executionContext)
@ -49,7 +50,7 @@ final class ApiParticipantPruningService private (
      .map(err => ErrorFactories.invalidArgument(s"submission_id $err"))

    submissionIdOrErr.fold(
-      Future.failed,
+      t => Future.failed(ValidationLogger.logFailure(request, t)(logger.withoutContext)),
      submissionId =>
        LoggingContext.withEnrichedLoggingContext(logging.submissionId(submissionId)) {
          implicit logCtx =>
@ -76,7 +77,10 @@ final class ApiParticipantPruningService private (
      pruneUpToString <- checkOffsetIsSpecified(request.pruneUpTo)
      pruneUpTo <- checkOffsetIsHexadecimal(pruneUpToString)
    } yield (pruneUpTo, pruneUpToString))
-      .fold(Future.failed, o => checkOffsetIsBeforeLedgerEnd(o._1, o._2))
+      .fold(
+        t => Future.failed(ValidationLogger.logFailureWithContext(request, t)),
+        o => checkOffsetIsBeforeLedgerEnd(o._1, o._2),
+      )
  }

  private def pruneWriteService(pruneUpTo: Offset, submissionId: SubmissionId)(implicit
--- a/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPartyManagementService.scala
+++ b/ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPartyManagementService.scala
@ -24,6 +24,7 @@ import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.platform.api.grpc.GrpcApiService
 import com.daml.platform.apiserver.services.admin.ApiPartyManagementService._
 import com.daml.platform.apiserver.services.logging
+import com.daml.platform.server.api.ValidationLogger
 import com.daml.platform.server.api.validation.ErrorFactories
 import com.daml.telemetry.{DefaultTelemetry, TelemetryContext}
 import io.grpc.{ServerServiceDefinition, StatusRuntimeException}
@ -44,7 +45,7 @@ private[apiserver] final class ApiPartyManagementService private (
 ) extends PartyManagementService
    with GrpcApiService {

-  private val logger = ContextualizedLogger.get(this.getClass)
+  private implicit val logger: ContextualizedLogger = ContextualizedLogger.get(this.getClass)

  private val synchronousResponse = new SynchronousResponse(
    new SynchronousResponseStrategy(transactionService, writeService, partyManagementService),
@ -102,7 +103,11 @@ private[apiserver] final class ApiPartyManagementService private (
          Ref.Party
            .fromString(request.partyIdHint)
            .fold(
-              error => Future.failed(ErrorFactories.invalidArgument(error)),
+              error =>
+                Future.failed(
+                  ValidationLogger
+                    .logFailureWithContext(request, ErrorFactories.invalidArgument(error))
+                ),
              party => Future.successful(Some(party)),
            )
        }