Initial metrics integration test

integration-tests/metrics-v4.2.19-expected-warnings.txt

@@ -0,0 +1,8 @@
+metrics-core/src/main/java/com/codahale/metrics/CsvReporter.java:[382,36] [FormatStringConcatenation] Defer string concatenation to the invoked method
+metrics-graphite/src/main/java/com/codahale/metrics/graphite/GraphiteReporter.java:[429,18] [Slf4jLogStatement] Log statement contains 0 placeholders, but specifies 1 matching argument(s)
+metrics-graphite/src/main/java/com/codahale/metrics/graphite/GraphiteReporter.java:[434,20] [Slf4jLogStatement] Log statement contains 0 placeholders, but specifies 1 matching argument(s)
+metrics-graphite/src/main/java/com/codahale/metrics/graphite/GraphiteReporter.java:[447,21] [Slf4jLogStatement] Log statement contains 0 placeholders, but specifies 1 matching argument(s)
+metrics-healthchecks/src/test/java/com/codahale/metrics/health/HealthCheckTest.java:[189,47] [TimeZoneUsage] Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone
+metrics-healthchecks/src/test/java/com/codahale/metrics/health/HealthCheckTest.java:[203,47] [TimeZoneUsage] Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone
+metrics-jakarta-servlets/src/test/java/io/dropwizard/metrics/servlets/HealthCheckServletTest.java:[29,68] [TimeZoneUsage] Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone
+metrics-servlets/src/test/java/com/codahale/metrics/servlets/HealthCheckServletTest.java:[30,68] [TimeZoneUsage] Derive the current time from an existing `Clock` Spring bean, and don't rely on a `Clock`'s time zone

integration-tests/metrics-v4.2.19-init.patch

@@ -0,0 +1,219 @@
+diff --git a/metrics-jakarta-servlets/src/main/java/io/dropwizard/metrics/servlets/MetricsServlet.java b/metrics-jakarta-servlets/src/main/java/io/dropwizard/metrics/servlets/MetricsServlet.java
+index a248dd8..4e7f053 100644
+--- a/metrics-jakarta-servlets/src/main/java/io/dropwizard/metrics/servlets/MetricsServlet.java
++++ b/metrics-jakarta-servlets/src/main/java/io/dropwizard/metrics/servlets/MetricsServlet.java
+@@ -188,6 +188,7 @@ public class MetricsServlet extends HttpServlet {
+         return mapper.writer();
+     }
+ 
++    @SuppressWarnings("IdentityConversion")
+     protected TimeUnit parseTimeUnit(String value, TimeUnit defaultValue) {
+         try {
+             return TimeUnit.valueOf(String.valueOf(value).toUpperCase(Locale.US));
+diff --git a/metrics-servlets/src/main/java/com/codahale/metrics/servlets/MetricsServlet.java b/metrics-servlets/src/main/java/com/codahale/metrics/servlets/MetricsServlet.java
+index 0bd1297..7c69a08 100644
+--- a/metrics-servlets/src/main/java/com/codahale/metrics/servlets/MetricsServlet.java
++++ b/metrics-servlets/src/main/java/com/codahale/metrics/servlets/MetricsServlet.java
+@@ -189,6 +189,7 @@ public class MetricsServlet extends HttpServlet {
+         return mapper.writer();
+     }
+ 
++    @SuppressWarnings("IdentityConversion")
+     protected TimeUnit parseTimeUnit(String value, TimeUnit defaultValue) {
+         try {
+             return TimeUnit.valueOf(String.valueOf(value).toUpperCase(Locale.US));
+diff --git a/pom.xml b/pom.xml
+index 6192b52..f1eebbe 100644
+--- a/pom.xml
++++ b/pom.xml
+@@ -66,7 +66,7 @@
+         <junit.version>4.13.1</junit.version>
+         <hamcrest.version>1.3</hamcrest.version>
+         <maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
+-        <errorprone.version>2.19.1</errorprone.version>
++        <error-prone-support.flags>-Xplugin:ErrorProne ${error-prone.flags} -Xep:CollectorMutability:OFF -XepOpt:Refaster:NamePattern=^((?!(Immutable|Preconditions|StringRules\$StringIsNullOrEmpty)).*)</error-prone-support.flags>
+         <errorprone.javac.version>9+181-r4173-1</errorprone.javac.version>
+ 
+         <sonar.projectKey>dropwizard_metrics</sonar.projectKey>
+@@ -137,60 +137,110 @@
+ 
+     <profiles>
+         <profile>
+-            <id>jdk8</id>
+-            <activation>
+-                <jdk>1.8</jdk>
+-            </activation>
++            <id>error-prone-compile</id>
+             <build>
+                 <plugins>
+-                    <plugin>
+-                        <groupId>org.apache.maven.plugins</groupId>
+-                        <artifactId>maven-compiler-plugin</artifactId>
++                  <plugin>
++                    <groupId>org.apache.maven.plugins</groupId>
++                    <artifactId>maven-compiler-plugin</artifactId>
++                    <version>${maven-compiler-plugin.version}</version>
++                    <executions>
++                      <execution>
++                        <id>error-prone-compile</id>
++                        <phase>compile</phase>
++                        <goals>
++                          <goal>compile</goal>
++                        </goals>
+                         <configuration>
+-                            <compilerArgs combine.children="append">
+-                                <arg>-J-Xbootclasspath/p:${settings.localRepository}/com/google/errorprone/javac/${errorprone.javac.version}/javac-${errorprone.javac.version}.jar</arg>
+-                            </compilerArgs>
++                          <failOnError>false</failOnError>
++                          <source>1.8</source>
++                          <target>1.8</target>
++                          <compilerArgs combine.children="append">
++                            <arg>-Xpkginfo:always</arg>
++                            <arg>-XDcompilePolicy=simple</arg>
++                            <arg>${error-prone-support.flags}</arg>
++                          </compilerArgs>
++                          <annotationProcessorPaths combine.children="append">
++                            <path>
++                              <groupId>com.google.errorprone</groupId>
++                              <artifactId>error_prone_core</artifactId>
++                              <version>${error-prone.version}</version>
++                            </path>
++                            <path>
++                              <groupId>tech.picnic.error-prone-support</groupId>
++                              <artifactId>error-prone-contrib</artifactId>
++                              <version>${error-prone-support.version}</version>
++                            </path>
++                            <path>
++                              <groupId>tech.picnic.error-prone-support</groupId>
++                              <artifactId>refaster-runner</artifactId>
++                              <version>${error-prone-support.version}</version>
++                            </path>
++                          </annotationProcessorPaths>
+                         </configuration>
+-                    </plugin>
++                      </execution>
++                    </executions>
++                  </plugin>
+                 </plugins>
+-            </build>
++              </build>
+         </profile>
+         <profile>
+-            <id>jdk17</id>
+-            <activation>
+-                <jdk>[17,)</jdk>
+-            </activation>
++            <id>error-prone-test-compile</id>
+             <build>
+-                <plugins>
+-                    <plugin>
+-                        <groupId>org.apache.maven.plugins</groupId>
+-                        <artifactId>maven-compiler-plugin</artifactId>
+-                        <configuration>
+-                            <compilerArgs>
+-                                <arg>-Xlint:all</arg>
+-                                <arg>-XDcompilePolicy=simple</arg>
+-                                <arg>-Xplugin:ErrorProne -XepExcludedPaths:.*/target/generated-sources/.*</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
+-                                <arg>-J--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
+-                                <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
+-                                <arg>-J--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED</arg>
+-                            </compilerArgs>
+-                            <annotationProcessorPaths>
+-                                <path>
+-                                    <groupId>com.google.errorprone</groupId>
+-                                    <artifactId>error_prone_core</artifactId>
+-                                    <version>${errorprone.version}</version>
+-                                </path>
+-                            </annotationProcessorPaths>
+-                        </configuration>
+-                    </plugin>
+-                </plugins>
++              <plugins>
++                <plugin>
++                  <groupId>org.apache.maven.plugins</groupId>
++                  <artifactId>maven-compiler-plugin</artifactId>
++                  <version>${maven-compiler-plugin.version}</version>
++                  <executions>
++                    <!-- Skip the default-testCompile execution as we don't want to execute the testCompile goal twice -->
++                    <execution>
++                      <id>default-testCompile</id>
++                      <phase>test-compile</phase>
++                      <goals>
++                        <goal>testCompile</goal>
++                      </goals>
++                      <configuration>
++                        <skip>true</skip>
++                      </configuration>
++                    </execution>
++                    <execution>
++                      <id>error-prone-test-compile</id>
++                      <phase>test-compile</phase>
++                      <goals>
++                        <goal>testCompile</goal>
++                      </goals>
++                      <configuration>
++                        <failOnError>false</failOnError>
++                        <source>1.8</source>
++                        <target>1.8</target>
++                        <compilerArgs combine.children="append">
++                          <arg>-Xpkginfo:always</arg>
++                          <arg>-XDcompilePolicy=simple</arg>
++                          <arg>${error-prone-support.flags}</arg>
++                        </compilerArgs>
++                        <annotationProcessorPaths>
++                          <path>
++                            <groupId>com.google.errorprone</groupId>
++                            <artifactId>error_prone_core</artifactId>
++                            <version>${error-prone.version}</version>
++                          </path>
++                          <path>
++                            <groupId>tech.picnic.error-prone-support</groupId>
++                            <artifactId>error-prone-contrib</artifactId>
++                            <version>${error-prone-support.version}</version>
++                          </path>
++                          <path>
++                            <groupId>tech.picnic.error-prone-support</groupId>
++                            <artifactId>refaster-runner</artifactId>
++                            <version>${error-prone-support.version}</version>
++                          </path>
++                        </annotationProcessorPaths>
++                      </configuration>
++                    </execution>
++                  </executions>
++                </plugin>
++              </plugins>
+             </build>
+         </profile>
+         <profile>
+@@ -315,23 +365,13 @@
+                 <groupId>org.apache.maven.plugins</groupId>
+                 <artifactId>maven-compiler-plugin</artifactId>
+                 <configuration>
+-                    <source>1.8</source>
+-                    <target>1.8</target>
+-                    <fork>true</fork>
++                    <fork>false</fork>
+                     <parameters>true</parameters>
+                     <showWarnings>true</showWarnings>
+                     <compilerArgs>
+                         <arg>-Xlint:all</arg>
+                         <arg>-XDcompilePolicy=simple</arg>
+-                        <arg>-Xplugin:ErrorProne -XepExcludedPaths:.*/target/generated-sources/.*</arg>
+                     </compilerArgs>
+-                    <annotationProcessorPaths>
+-                        <path>
+-                            <groupId>com.google.errorprone</groupId>
+-                            <artifactId>error_prone_core</artifactId>
+-                            <version>${errorprone.version}</version>
+-                        </path>
+-                    </annotationProcessorPaths>
+                 </configuration>
+             </plugin>
+             <plugin>

integration-tests/metrics-v4.2.19.sh

@@ -0,0 +1,180 @@
+#!/usr/bin/env bash
+
+set -e -u -o pipefail
+
+integration_test_root="$(readlink -f "$(dirname "${0}")")"
+error_prone_support_root="${integration_test_root}/.."
+repos_root="${integration_test_root}/.repos"
+
+test_name="$(basename "${0}" .sh)"
+project=metrics
+repository=https://github.com/dropwizard/metrics.git
+revision=v4.2.19
+
+if [ "${#}" -gt 2 ] || ([ "${#}" = 2 ] && [ "${1:---sync}" != '--sync' ]); then
+  echo "Usage: ${0} [--sync] [<report_directory>]"
+  exit 1
+fi
+do_sync="$([ "${#}" = 0 ] || [ "${1:-}" != '--sync' ] || echo 1)"
+report_directory="$([ "${#}" = 0 ] || ([ -z "${do_sync}" ] && echo "${1}") || ([ "${#}" = 1 ] || echo "${2}"))"
+
+if [ -n "${report_directory}" ]; then
+  mkdir -p "${report_directory}"
+else
+  report_directory="$(mktemp -d)"
+  trap 'rm -rf -- "${report_directory}"' INT TERM HUP EXIT
+fi
+
+# XXX: Configure Renovate to manage the AssertJ version declared here.
+shared_build_flags="
+  -Perror-prone-compile,error-prone-test-compile
+  -Dassertj.version=3.24.2
+  -Derror-prone.version=$(
+    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=version.error-prone -q -DforceStdout
+  )
+  -Derror-prone-support.version=$(
+    mvn -f "${error_prone_support_root}" help:evaluate -Dexpression=project.version -q -DforceStdout
+  )
+  -DadditionalSourceDirectories=\${project.basedir}\${file.separator}src\${file.separator}it\${file.separator}java,\${project.basedir}\${file.separator}src\${file.separator}xdocs-examples\${file.separator}java
+  "
+
+# XXX: Configure Renovate to manage the fmt-maven-plugin version declared here.
+# XXX: Once GitHub actions uses Maven 3.9.2+, we can inline this variable with
+# version reference `${fmt.version}`, and `-Dfmt.version=2.21.1` added to
+# `shared_build_flags`.
+format_goal='com.spotify.fmt:fmt-maven-plugin:2.21.1:format'
+
+error_prone_shared_flags='-XepExcludedPaths:(\Q${project.basedir}${file.separator}src${file.separator}\E(it|test|xdocs-examples)\Q${file.separator}resources\E|\Q${project.build.directory}${file.separator}\E).*'
+
+error_prone_patch_flags="${error_prone_shared_flags} -XepPatchLocation:IN_PLACE -XepPatchChecks:$(
+  find "${error_prone_support_root}" -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" -print0 \
+    | xargs -0 grep -hoP '[^.]+$' \
+    | paste -s -d ','
+)"
+
+error_prone_validation_flags="${error_prone_shared_flags} -XepDisableAllChecks $(
+  find "${error_prone_support_root}" -path "*/META-INF/services/com.google.errorprone.bugpatterns.BugChecker" -print0 \
+    | xargs -0 grep -hoP '[^.]+$' \
+    | sed -r 's,(.*),-Xep:\1:WARN,' \
+    | paste -s -d ' '
+)"
+
+echo "Shared build flags: ${shared_build_flags}"
+echo "Error Prone patch flags: ${error_prone_patch_flags}"
+echo "Error Prone validation flags: ${error_prone_validation_flags}"
+
+mkdir -p "${repos_root}"
+
+# Make sure that the targeted tag of the project's Git repository is checked
+# out.
+project_root="${repos_root}/${project}"
+if [ ! -d "${project_root}" ]; then
+  # The repository has not yet been cloned; create a shallow clone.
+  git clone --branch "${revision}" --depth 1 "${repository}" "${project_root}"
+else
+  # The repository does already appear to exist. Try to check out the requested
+  # tag if possible, and fetch it otherwise.
+  #
+  # Under certain circumstances this does not cause the relevant tag to be
+  # created, so if necessary we manually create it.
+  git -C "${project_root}" checkout --force "${revision}" 2>/dev/null \
+    || (
+         git -C "${project_root}" fetch --depth 1 "${repository}" "${revision}" \
+           && git -C "${project_root}" checkout --force FETCH_HEAD \
+           && (git -C "${project_root}" tag "${revision}" || true)
+       )
+fi
+
+pushd "${project_root}"
+
+# Make sure that Git is sufficiently configured to enable committing to the
+# project's Git repository.
+git config user.email || git config user.email "integration-test@example.com"
+git config user.name || git config user.name "Integration Test"
+
+# Prepare the code for analysis by (a) applying the minimal set of changes
+# required to run Error Prone with Error Prone Support and (b) formatting the
+# code using the same method by which it will be formatted after each
+# compilation round. The initial formatting operation ensures that subsequent
+# modifications can be rendered in a clean manner.
+git clean -fdx
+git apply < "${integration_test_root}/${test_name}-init.patch"
+git commit -m 'dependency: Introduce Error Prone Support' .
+mvn ${shared_build_flags} "${format_goal}"
+git commit -m 'minor: Reformat using Google Java Format' .
+diff_base="$(git rev-parse HEAD)"
+
+# Apply Error Prone Support-suggested changes until a fixed point is reached.
+function apply_patch() {
+  local extra_build_args="${1}"
+
+  mvn ${shared_build_flags} ${extra_build_args} \
+    package "${format_goal}" \
+    -Derror-prone.flags="${error_prone_patch_flags}" \
+    -DskipTests
+
+  if ! git diff --exit-code; then
+    git commit -m 'minor: Apply patches' .
+
+    # Changes were applied, so another compilation round may apply yet more
+    # changes. For performance reasons we perform incremental compilation,
+    # enabled using a misleading flag. (See
+    # https://issues.apache.org/jira/browse/MCOMPILER-209 for details.)
+    apply_patch '-Dmaven.compiler.useIncrementalCompilation=false'
+  elif [ "${extra_build_args}" != 'clean' ]; then
+    # No changes were applied. We'll attempt one more round in which all files
+    # are recompiled, because there are cases in which violations are missed
+    # during incremental compilation.
+    apply_patch 'clean'
+  fi
+}
+apply_patch ''
+
+# Run one more full build and log the output.
+#
+# By also running the tests, we validate that the (majority of) applied changes
+# are behavior preserving. Some tests are skipped:
+# - The `metadataFilesGenerationAllFiles` test is skipped because it makes line
+#   number assertions that will fail when the code is formatted or patched.
+# - The `allCheckSectionJavaDocs` test is skipped because is validates that
+#   Javadoc has certain closing tags that are removed by Google Java Format.
+validation_build_log="${report_directory}/${test_name}-validation-build-log.txt"
+mvn ${shared_build_flags} \
+      clean package \
+      -Derror-prone.flags="${error_prone_validation_flags}" \
+    | tee "${validation_build_log}" \
+  || failure=1
+
+# Collect the applied changes.
+expected_changes="${integration_test_root}/${test_name}-expected-changes.patch"
+actual_changes="${report_directory}/${test_name}-changes.patch"
+(git diff "${diff_base}"..HEAD | grep -vP '^(diff|index)' || true) > "${actual_changes}"
+
+# Collect the warnings reported by Error Prone Support checks.
+expected_warnings="${integration_test_root}/${test_name}-expected-warnings.txt"
+actual_warnings="${report_directory}/${test_name}-validation-build-warnings.txt"
+(grep -oP "(?<=^\\Q[WARNING] ${PWD}/\\E).*" "${validation_build_log}" | grep -P '\] \[' || true) | LC_ALL=C sort > "${actual_warnings}"
+
+# Persist or validate the applied changes and reported warnings.
+if [ -n "${do_sync}" ]; then
+  echo 'Saving changes...'
+  cp "${actual_changes}" "${expected_changes}"
+  cp "${actual_warnings}" "${expected_warnings}"
+else
+  echo 'Inspecting changes...'
+  # XXX: This "diff of diffs" also contains vacuous sections, introduced due to
+  # line offset differences. Try to omit those from the final output.
+  if ! diff -u "${expected_changes}" "${actual_changes}"; then
+    echo 'There are unexpected changes.'
+    failure=1
+  fi
+  echo 'Inspecting emitted warnings...'
+  if ! diff -u "${expected_warnings}" "${actual_warnings}"; then
+    echo 'Diagnostics output changed.'
+    failure=1
+  fi
+fi
+
+if [ -n "${failure:-}" ]; then
+  exit 1
+fi