@@ -0,0 +1,59 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0.server;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasSuperType;
+import static net.bytebuddy.matcher.ElementMatchers.isAbstract;
+import static net.bytebuddy.matcher.ElementMatchers.isBridge;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.not;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+import org.apache.pekko.http.javadsl.model.HttpResponse;
+
+/**
+ * A request that fails to parse, for example because of an illegal request-target, is answered by
+ * {@code HttpServerBluePrint$ControllerStage}, which sits below the stage that the server
+ * instrumentation wraps. The rejected request never becomes an {@code HttpRequest} and never
+ * reaches the user handler, so the only hook that sees it is the parsing error handler.
+ */
+class ParsingErrorHandlerInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("org.apache.pekko.http.ParsingErrorHandler");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return hasSuperType(named("org.apache.pekko.http.ParsingErrorHandler"));
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    // a scala implementation returns the more specific scaladsl HttpResponse and gets a bridge
+    // method for the signature declared on ParsingErrorHandler; skipping the bridge leaves exactly
+    // one match per implementation, whichever of the two return types it declares
+    transformer.applyAdviceToMethod(
+        named("handle").and(not(isAbstract())).and(not(isBridge())).and(takesArguments(4)),
+        getClass().getName() + "$HandleAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class HandleAdvice {
+
+    @Advice.OnMethodExit(suppress = Throwable.class, inline = false)
+    public static void onExit(@Advice.Return Object response) {
+      PekkoHttpParsingErrorSingletons.emitSpan((HttpResponse) response);
+    }
+  }
+}
@@ -0,0 +1,18 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0.server;
+
+/**
+ * Marker for a request that pekko-http rejected while parsing it. Such a request never becomes an
+ * {@code HttpRequest}, so there is nothing to describe it with beyond the response that pekko-http
+ * synthesized.
+ */
+final class PekkoHttpParsingError {
+
+  static final PekkoHttpParsingError INSTANCE = new PekkoHttpParsingError();
+
+  private PekkoHttpParsingError() {}
+}
@@ -0,0 +1,62 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0.server;
+
+import static java.util.Collections.emptyList;
+
+import io.opentelemetry.instrumentation.api.semconv.http.HttpServerAttributesGetter;
+import java.util.List;
+import javax.annotation.Nullable;
+import org.apache.pekko.http.javadsl.model.HttpResponse;
+
+/**
+ * The request failed to parse, so the only thing known about it is the response that pekko-http
+ * generated. Everything that would come from the request is reported as unknown.
+ */
+class PekkoHttpParsingErrorAttributesGetter
+    implements HttpServerAttributesGetter<PekkoHttpParsingError, HttpResponse> {
+
+  @Nullable
+  @Override
+  public String getHttpRequestMethod(PekkoHttpParsingError request) {
+    return null;
+  }
+
+  @Override
+  public List<String> getHttpRequestHeader(PekkoHttpParsingError request, String name) {
+    return emptyList();
+  }
+
+  @Override
+  public Integer getHttpResponseStatusCode(
+      PekkoHttpParsingError request, HttpResponse response, @Nullable Throwable error) {
+    return response.status().intValue();
+  }
+
+  @Override
+  public List<String> getHttpResponseHeader(
+      PekkoHttpParsingError request, HttpResponse response, String name) {
+    return emptyList();
+  }
+
+  @Nullable
+  @Override
+  public String getUrlScheme(PekkoHttpParsingError request) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public String getUrlPath(PekkoHttpParsingError request) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public String getUrlQuery(PekkoHttpParsingError request) {
+    return null;
+  }
+}
@@ -0,0 +1,63 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0.server;
+
+import static io.opentelemetry.instrumentation.api.internal.HttpConstants._OTHER;
+import static io.opentelemetry.semconv.HttpAttributes.HTTP_REQUEST_METHOD;
+import static java.util.Collections.emptyList;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
+import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
+import io.opentelemetry.javaagent.bootstrap.internal.JavaagentHttpServerInstrumenters;
+import io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0.PekkoHttpUtil;
+import javax.annotation.Nullable;
+import org.apache.pekko.http.javadsl.model.HttpResponse;
+
+/**
+ * Creates spans for requests that pekko-http rejected while parsing them. These requests never
+ * reach the user handler, and never become an {@code HttpRequest}, so the regular server
+ * instrumentation in {@link PekkoHttpServerTracer} does not see them.
+ */
+public final class PekkoHttpParsingErrorSingletons {
+
+  private static final Instrumenter<PekkoHttpParsingError, HttpResponse> INSTRUMENTER =
+      JavaagentHttpServerInstrumenters.create(
+          PekkoHttpUtil.instrumentationName(),
+          new PekkoHttpParsingErrorAttributesGetter(),
+          NoopTextMapGetter.INSTANCE,
+          // the request method could not be parsed, so it is reported as unknown
+          builder ->
+              builder.addAttributesExtractor(
+                  AttributesExtractor.constant(HTTP_REQUEST_METHOD, _OTHER)));
+
+  public static void emitSpan(HttpResponse response) {
+    Context parentContext = Context.current();
+    if (!INSTRUMENTER.shouldStart(parentContext, PekkoHttpParsingError.INSTANCE)) {
+      return;
+    }
+    Context context = INSTRUMENTER.start(parentContext, PekkoHttpParsingError.INSTANCE);
+    INSTRUMENTER.end(context, PekkoHttpParsingError.INSTANCE, response, null);
+  }
+
+  private enum NoopTextMapGetter implements TextMapGetter<PekkoHttpParsingError> {
+    INSTANCE;
+
+    @Override
+    public Iterable<String> keys(PekkoHttpParsingError carrier) {
+      return emptyList();
+    }
+
+    @Nullable
+    @Override
+    public String get(@Nullable PekkoHttpParsingError carrier, String key) {
+      return null;
+    }
+  }
+
+  private PekkoHttpParsingErrorSingletons() {}
+}
@@ -35,6 +35,7 @@ public List<TypeInstrumentation> typeInstrumentations() {
         new HttpPrepareAttributesInstrumentation(),
         new HttpServerBluePrintInstrumentation(),
         new GraphInterpreterInstrumentation(),
+        new ParsingErrorHandlerInstrumentation(),
         new PekkoHttpServerSourceInstrumentation(),
         new Http2ExtServerInstrumentation(),
         new Http2RequestParsingInstrumentation());
 
@@ -0,0 +1,111 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.pekkohttp.v1_0
+
+import io.opentelemetry.api.trace.SpanKind
+import io.opentelemetry.instrumentation.testing.junit.{
+  AgentInstrumentationExtension,
+  InstrumentationExtension
+}
+import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo
+import io.opentelemetry.sdk.testing.assertj.{SpanDataAssert, TraceAssert}
+import io.opentelemetry.semconv.HttpAttributes
+import org.apache.pekko.actor.ActorSystem
+import org.apache.pekko.http.scaladsl.Http
+import org.apache.pekko.http.scaladsl.model.{HttpRequest, HttpResponse}
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.RegisterExtension
+
+import java.io.{BufferedReader, InputStreamReader, OutputStreamWriter}
+import java.net.{ServerSocket, Socket}
+import java.nio.charset.StandardCharsets
+import java.util.function.Consumer
+import scala.collection.mutable.ListBuffer
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+/** A request that pekko-http rejects while parsing it never becomes an
+  * HttpRequest and never reaches the user handler, so it is traced through the
+  * parsing error handler rather than through the regular server
+  * instrumentation.
+  */
+class PekkoHttpServerParsingErrorTest {
+
+  @RegisterExtension val testing: InstrumentationExtension =
+    AgentInstrumentationExtension.create()
+
+  @Test def illegalRequestTargetIsTraced(): Unit = {
+    // this test does not share the web server used by the other tests, it needs a server that is
+    // guaranteed to be running and no other test may terminate its actor system
+    implicit val system: ActorSystem = ActorSystem("parsing-error-test")
+    try {
+      val port = {
+        val socket = new ServerSocket(0)
+        try socket.getLocalPort
+        finally socket.close()
+      }
+      val handler: HttpRequest => HttpResponse = _ => HttpResponse()
+      val binding =
+        Await.result(
+          Http().bindAndHandleSync(handler, "localhost", port),
+          10.seconds
+        )
+
+      try {
+        val response = send(
+          port,
+          "GET /%% HTTP/1.1\r\nHost: localhost:" + port + "\r\n\r\n"
+        )
+        assertThat(response.head).contains("400 Bad Request")
+
+        testing.waitAndAssertTraces(new Consumer[TraceAssert] {
+          override def accept(trace: TraceAssert): Unit =
+            trace.hasSpansSatisfyingExactly(new Consumer[SpanDataAssert] {
+              override def accept(span: SpanDataAssert): Unit = {
+                span
+                  .hasName("HTTP")
+                  .hasKind(SpanKind.SERVER)
+                  .hasNoParent()
+                  .hasAttributesSatisfying(
+                    equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "_OTHER"),
+                    equalTo(
+                      HttpAttributes.HTTP_RESPONSE_STATUS_CODE,
+                      java.lang.Long.valueOf(400)
+                    )
+                  )
+                ()
+              }
+            })
+        })
+      } finally Await.result(binding.unbind(), 10.seconds)
+    } finally Await.result(system.terminate(), 10.seconds)
+  }
+
+  private def send(port: Int, request: String): List[String] = {
+    val socket = new Socket("localhost", port)
+    try {
+      val out =
+        new OutputStreamWriter(
+          socket.getOutputStream,
+          StandardCharsets.US_ASCII
+        )
+      out.write(request)
+      out.flush()
+
+      val in = new BufferedReader(
+        new InputStreamReader(socket.getInputStream, StandardCharsets.US_ASCII)
+      )
+      val lines = ListBuffer[String]()
+      var line = in.readLine()
+      while (line != null) {
+        lines += line
+        line = in.readLine()
+      }
+      lines.toList
+    } finally socket.close()
+  }
+}