Update spotless version (#4296)

* Update spotless version

* Apply new spotless version

benchmark-overhead-jmh/build.gradle.kts

@@ -53,13 +53,15 @@ tasks {
       "-Dotel.instrumentation.http-url-connection.enabled=false"
     )
     if (jmhStartFlightRecording != null) {
-      args.addAll(listOf(
+      args.addAll(
-        "-XX:+FlightRecorder",
+        listOf(
-        "-XX:StartFlightRecording=$jmhStartFlightRecording",
+          "-XX:+FlightRecorder",
-        // enabling profiling at non-safepoints helps with micro-profiling
+          "-XX:StartFlightRecording=$jmhStartFlightRecording",
-        "-XX:+UnlockDiagnosticVMOptions",
+          // enabling profiling at non-safepoints helps with micro-profiling
-        "-XX:+DebugNonSafepoints"
+          "-XX:+UnlockDiagnosticVMOptions",
-      ))
+          "-XX:+DebugNonSafepoints"
+        )
+      )
     }
     // see https://github.com/melix/jmh-gradle-plugin/issues/200
     jvmArgsPrepend.add(args.joinToString(" "))

build.gradle.kts

@@ -1,5 +1,5 @@
-import java.time.Duration
 import nebula.plugin.release.git.opinion.Strategies
+import java.time.Duration
 
 plugins {
   id("idea")

conventions/build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
   `java-gradle-plugin`
   `kotlin-dsl`
   // When updating, update below in dependencies too
-  id("com.diffplug.spotless") version "5.13.0"
+  id("com.diffplug.spotless") version "5.16.0"
 }
 
 spotless {
@@ -37,7 +37,7 @@ dependencies {
   implementation("org.apache.maven:maven-aether-provider:3.3.9")
 
   // When updating, update above in plugins too
-  implementation("com.diffplug.spotless:spotless-plugin-gradle:5.14.0")
+  implementation("com.diffplug.spotless:spotless-plugin-gradle:5.16.0")
   implementation("com.google.guava:guava:30.1-jre")
   implementation("gradle.plugin.com.github.jengelman.gradle.plugins:shadow:7.0.0")
   implementation("org.ow2.asm:asm:9.1")

instrumentation/akka-http-10.0/javaagent/src/test/scala/AkkaHttpTestAsyncWebServer.scala

@@ -29,7 +29,9 @@ object AkkaHttpTestAsyncWebServer {
           endpoint,
           new Closure[HttpResponse](()) {
             def doCall(): HttpResponse = {
-              val resp = HttpResponse(status = endpoint.getStatus) //.withHeaders(headers.Type)resp.contentType = "text/plain"
+              val resp = HttpResponse(status =
+                endpoint.getStatus
+              ) //.withHeaders(headers.Type)resp.contentType = "text/plain"
               endpoint match {
                 case SUCCESS => resp.withEntity(endpoint.getBody)
                 case INDEXED_CHILD =>

instrumentation/akka-http-10.0/javaagent/src/test/scala/AkkaHttpTestWebServer.scala

@@ -21,11 +21,10 @@ object AkkaHttpTestWebServer {
   // needed for the future flatMap/onComplete in the end
   implicit val executionContext = system.dispatcher
 
-  val exceptionHandler = ExceptionHandler {
+  val exceptionHandler = ExceptionHandler { case ex: Exception =>
-    case ex: Exception =>
+    complete(
-      complete(
+      HttpResponse(status = EXCEPTION.getStatus).withEntity(ex.getMessage)
-        HttpResponse(status = EXCEPTION.getStatus).withEntity(ex.getMessage)
+    )
-      )
   }
 
   val route = { //handleExceptions(exceptionHandler) {

instrumentation/finatra-2.9/javaagent/src/latestDepTest/scala/FinatraController.scala

@@ -12,42 +12,57 @@ import io.opentelemetry.instrumentation.test.base.HttpServerTest.controller
 
 class FinatraController extends Controller {
   any(SUCCESS.getPath) { request: Request =>
-    controller(SUCCESS, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      SUCCESS,
-        response.ok(SUCCESS.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.ok(SUCCESS.getBody)
+        }
       }
-    })
+    )
   }
 
   any(ERROR.getPath) { request: Request =>
-    controller(ERROR, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      ERROR,
-        response.internalServerError(ERROR.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.internalServerError(ERROR.getBody)
+        }
       }
-    })
+    )
   }
 
   any(QUERY_PARAM.getPath) { request: Request =>
-    controller(QUERY_PARAM, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      QUERY_PARAM,
-        response.ok(QUERY_PARAM.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.ok(QUERY_PARAM.getBody)
+        }
       }
-    })
+    )
   }
 
   any(EXCEPTION.getPath) { request: Request =>
-    controller(EXCEPTION, new Closure[Future[Response]](null) {
+    controller(
-      override def call(): Future[Response] = {
+      EXCEPTION,
-        throw new Exception(EXCEPTION.getBody)
+      new Closure[Future[Response]](null) {
+        override def call(): Future[Response] = {
+          throw new Exception(EXCEPTION.getBody)
+        }
       }
-    })
+    )
   }
 
   any(REDIRECT.getPath) { request: Request =>
-    controller(REDIRECT, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      REDIRECT,
-        response.found.location(REDIRECT.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.found.location(REDIRECT.getBody)
+        }
       }
-    })
+    )
   }
 }

instrumentation/finatra-2.9/javaagent/src/latestDepTest/scala/ResponseSettingExceptionMapper.scala

@@ -9,7 +9,7 @@ import com.twitter.finatra.http.response.ResponseBuilder
 import javax.inject.{Inject, Singleton}
 
 @Singleton
-class ResponseSettingExceptionMapper @Inject()(response: ResponseBuilder)
+class ResponseSettingExceptionMapper @Inject() (response: ResponseBuilder)
     extends ExceptionMapper[Exception] {
 
   override def toResponse(request: Request, exception: Exception): Response = {

instrumentation/finatra-2.9/javaagent/src/test/scala/FinatraController.scala

@@ -12,50 +12,68 @@ import io.opentelemetry.instrumentation.test.base.HttpServerTest.controller
 
 class FinatraController extends Controller {
   any(SUCCESS.getPath) { request: Request =>
-    controller(SUCCESS, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      SUCCESS,
-        response.ok(SUCCESS.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.ok(SUCCESS.getBody)
+        }
       }
-    })
+    )
   }
 
   any(ERROR.getPath) { request: Request =>
-    controller(ERROR, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      ERROR,
-        response.internalServerError(ERROR.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.internalServerError(ERROR.getBody)
+        }
       }
-    })
+    )
   }
 
   any(QUERY_PARAM.getPath) { request: Request =>
-    controller(QUERY_PARAM, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      QUERY_PARAM,
-        response.ok(QUERY_PARAM.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.ok(QUERY_PARAM.getBody)
+        }
       }
-    })
+    )
   }
 
   any(EXCEPTION.getPath) { request: Request =>
-    controller(EXCEPTION, new Closure[Future[Response]](null) {
+    controller(
-      override def call(): Future[Response] = {
+      EXCEPTION,
-        throw new Exception(EXCEPTION.getBody)
+      new Closure[Future[Response]](null) {
+        override def call(): Future[Response] = {
+          throw new Exception(EXCEPTION.getBody)
+        }
       }
-    })
+    )
   }
 
   any(REDIRECT.getPath) { request: Request =>
-    controller(REDIRECT, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      REDIRECT,
-        response.found.location(REDIRECT.getBody)
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.found.location(REDIRECT.getBody)
+        }
       }
-    })
+    )
   }
 
   any("/path/:id/param") { request: Request =>
-    controller(PATH_PARAM, new Closure[Response](null) {
+    controller(
-      override def call(): Response = {
+      PATH_PARAM,
-        response.ok(request.params("id"))
+      new Closure[Response](null) {
+        override def call(): Response = {
+          response.ok(request.params("id"))
+        }
       }
-    })
+    )
   }
 }

instrumentation/finatra-2.9/javaagent/src/test/scala/ResponseSettingExceptionMapper.scala

@@ -9,7 +9,7 @@ import com.twitter.finatra.http.response.ResponseBuilder
 import javax.inject.{Inject, Singleton}
 
 @Singleton
-class ResponseSettingExceptionMapper @Inject()(response: ResponseBuilder)
+class ResponseSettingExceptionMapper @Inject() (response: ResponseBuilder)
     extends ExceptionMapper[Exception] {
 
   override def toResponse(request: Request, exception: Exception): Response = {

instrumentation/kotlinx-coroutines/javaagent/src/test/kotlin/KotlinCoroutineTests.kt

@@ -6,7 +6,6 @@
 import io.opentelemetry.api.GlobalOpenTelemetry
 import io.opentelemetry.api.trace.Tracer
 import io.opentelemetry.extension.kotlin.asContextElement
-import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
@@ -24,6 +23,7 @@ import kotlinx.coroutines.selects.select
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import kotlinx.coroutines.yield
+import java.util.concurrent.TimeUnit
 
 class KotlinCoroutineTests(private val dispatcher: CoroutineDispatcher) {
   val tracer: Tracer = GlobalOpenTelemetry.getTracer("test")

instrumentation/scala-executors/javaagent/src/test/scala/ScalaConcurrentTests.scala

@@ -59,16 +59,15 @@ class ScalaConcurrentTests {
       val goodFuture: Future[Integer] = Future {
         1
       }
-      goodFuture onSuccess {
+      goodFuture onSuccess { case _ =>
-        case _ =>
+        Future {
-          Future {
+          2
-            2
+        } onSuccess {
-          } onSuccess {
+          case _ => {
-            case _ => {
+            tracedChild("callback")
-              tracedChild("callback")
+            latch.countDown()
-              latch.countDown()
-            }
           }
+        }
       }
 
       latch.await()
@@ -131,16 +130,22 @@ class ScalaConcurrentTests {
     val parentScope =
       Java8BytecodeBridge.currentContext().`with`(parentSpan).makeCurrent()
     try {
-      val completedVal = Future.firstCompletedOf(List(Future {
+      val completedVal = Future.firstCompletedOf(
-        tracedChild("timeout1")
+        List(
-        false
+          Future {
-      }, Future {
+            tracedChild("timeout1")
-        tracedChild("timeout2")
+            false
-        false
+          },
-      }, Future {
+          Future {
-        tracedChild("timeout3")
+            tracedChild("timeout2")
-        true
+            false
-      }))
+          },
+          Future {
+            tracedChild("timeout3")
+            true
+          }
+        )
+      )
       Await.result(completedVal, 30 seconds)
     } finally {
       parentSpan.end()

testing/agent-for-testing/build.gradle.kts

@@ -28,9 +28,11 @@ tasks {
   // Extracts manifest from OpenTelemetry Java agent to reuse it later
   val agentManifest by registering(Copy::class) {
     dependsOn(agent)
-    from(zipTree(agent.singleFile).matching {
+    from(
-      include("META-INF/MANIFEST.MF")
+      zipTree(agent.singleFile).matching {
-    })
+        include("META-INF/MANIFEST.MF")
+      }
+    )
     into("$buildDir/tmp")
   }