Remove/deprecate obsolete constants in oal.util.Constants; remove code which is no longer executed after Java 9 (#978)

lucene/CHANGES.txt

@@ -79,6 +79,9 @@ API Changes
 * LUCENE-10603: SortedSetDocValues#NO_MORE_ORDS marked @deprecated in favor of iterating with
   SortedSetDocValues#docValueCount(). (Greg Miller)
 
+* GITHUB#978: Deprecate (remove in Lucene 10) obsolete constants in oal.util.Constants; remove
+  code which is no longer executed after Java 9. (Uwe Schindler)
+
 New Features
 ---------------------
 * LUCENE-10550: Add getAllChildren functionality to facets (Yuting Gan)
@@ -116,6 +119,12 @@ Optimizations
 * GITHUB#984: Use primitive type data structures in FloatTaxonomyFacets and IntTaxonomyFacets
   #getAllChildren() internal implementation to avoid some garbage creation. (Greg Miller)
 
+Changes in runtime behavior
+---------------------
+
+* GITHUB#978: IndexWriter diagnostics written to index only contain java's runtime version
+  and vendor. (Uwe Schindler)
+
 Bug Fixes
 ---------------------
 

lucene/core/src/java/org/apache/lucene/index/IndexWriter.java

@@ -21,12 +21,12 @@ import static org.apache.lucene.util.ByteBlockPool.BYTE_BLOCK_SIZE;
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.time.Instant;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Date;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -4775,14 +4775,9 @@ public class IndexWriter
     diagnostics.put("os", Constants.OS_NAME);
     diagnostics.put("os.arch", Constants.OS_ARCH);
     diagnostics.put("os.version", Constants.OS_VERSION);
-    diagnostics.put("java.version", Constants.JAVA_VERSION);
+    diagnostics.put("java.runtime.version", Runtime.version().toString());
     diagnostics.put("java.vendor", Constants.JAVA_VENDOR);
-    // On IBM J9 JVM this is better than java.version which is just 1.7.0 (no update level):
+    diagnostics.put("timestamp", Long.toString(Instant.now().toEpochMilli()));
-    diagnostics.put(
-        "java.runtime.version", System.getProperty("java.runtime.version", "undefined"));
-    // Hotspot version, e.g. 2.8 for J9:
-    diagnostics.put("java.vm.version", System.getProperty("java.vm.version", "undefined"));
-    diagnostics.put("timestamp", Long.toString(new Date().getTime()));
     if (details != null) {
       diagnostics.putAll(details);
     }

lucene/core/src/java/org/apache/lucene/util/Constants.java

@@ -16,8 +16,6 @@
  */
 package org.apache.lucene.util;
 
-import java.util.StringTokenizer;
-
 /** Some useful constants. */
 public final class Constants {
   private Constants() {} // can't construct
@@ -25,12 +23,32 @@ public final class Constants {
   /** JVM vendor info. */
   public static final String JVM_VENDOR = System.getProperty("java.vm.vendor");
 
-  public static final String JVM_VERSION = System.getProperty("java.vm.version");
+  /** JVM vendor name. */
   public static final String JVM_NAME = System.getProperty("java.vm.name");
-  public static final String JVM_SPEC_VERSION = System.getProperty("java.specification.version");
 
-  /** The value of <code>System.getProperty("java.version")</code>. * */
+  /**
-  public static final String JAVA_VERSION = System.getProperty("java.version");
+   * Get the full version string of the current runtime.
+   *
+   * @deprecated To detect Java versions use {@link Runtime#version()}
+   */
+  @Deprecated public static final String JVM_VERSION = Runtime.version().toString();
+
+  /**
+   * Gets the specification version of the current runtime. This is the feature version converted to
+   * String.
+   *
+   * @see java.lang.Runtime.Version#feature()
+   * @deprecated To detect Java versions use {@link Runtime#version()}
+   */
+  @Deprecated
+  public static final String JVM_SPEC_VERSION = Integer.toString(Runtime.version().feature());
+
+  /**
+   * The value of <code>System.getProperty("java.version")</code>.
+   *
+   * @deprecated To detect Java versions use {@link Runtime#version()}
+   */
+  @Deprecated public static final String JAVA_VERSION = System.getProperty("java.version");
 
   /** The value of <code>System.getProperty("os.name")</code>. * */
   public static final String OS_NAME = System.getProperty("os.name");
@@ -45,24 +63,19 @@ public final class Constants {
   /** True iff running on FreeBSD */
   public static final boolean FREE_BSD = OS_NAME.startsWith("FreeBSD");
 
+  /** The value of <code>System.getProperty("os.arch")</code>. */
   public static final String OS_ARCH = System.getProperty("os.arch");
-  public static final String OS_VERSION = System.getProperty("os.version");
-  public static final String JAVA_VENDOR = System.getProperty("java.vendor");
 
-  private static final int JVM_MAJOR_VERSION;
+  /** The value of <code>System.getProperty("os.version")</code>. */
-  private static final int JVM_MINOR_VERSION;
+  public static final String OS_VERSION = System.getProperty("os.version");
+
+  /** The value of <code>System.getProperty("java.vendor")</code>. */
+  public static final String JAVA_VENDOR = System.getProperty("java.vendor");
 
   /** True iff running on a 64bit JVM */
   public static final boolean JRE_IS_64BIT;
 
   static {
-    final StringTokenizer st = new StringTokenizer(JVM_SPEC_VERSION, ".");
-    JVM_MAJOR_VERSION = Integer.parseInt(st.nextToken());
-    if (st.hasMoreTokens()) {
-      JVM_MINOR_VERSION = Integer.parseInt(st.nextToken());
-    } else {
-      JVM_MINOR_VERSION = 0;
-    }
     boolean is64Bit = false;
     String datamodel = null;
     try {
@@ -84,10 +97,27 @@ public final class Constants {
     JRE_IS_64BIT = is64Bit;
   }
 
-  public static final boolean JRE_IS_MINIMUM_JAVA8 =
+  /**
-      JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 8);
+   * Always true.
-  public static final boolean JRE_IS_MINIMUM_JAVA9 =
+   *
-      JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 9);
+   * @deprecated This constant is useless and always {@code true}. To detect Java versions use
-  public static final boolean JRE_IS_MINIMUM_JAVA11 =
+   *     {@link Runtime#version()}
-      JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 11);
+   */
+  @Deprecated public static final boolean JRE_IS_MINIMUM_JAVA8 = true;
+
+  /**
+   * Always true.
+   *
+   * @deprecated This constant is useless and always {@code true}. To detect Java versions use
+   *     {@link Runtime#version()}
+   */
+  @Deprecated public static final boolean JRE_IS_MINIMUM_JAVA9 = true;
+
+  /**
+   * Always true.
+   *
+   * @deprecated This constant is useless and always {@code true}. To detect Java versions use
+   *     {@link Runtime#version()}
+   */
+  @Deprecated public static final boolean JRE_IS_MINIMUM_JAVA11 = true;
 }

lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java

@@ -70,7 +70,6 @@ import org.apache.lucene.tests.util.RamUsageTester;
 import org.apache.lucene.tests.util.TestUtil;
 import org.apache.lucene.util.Accountable;
 import org.apache.lucene.util.BytesRef;
-import org.apache.lucene.util.Constants;
 import org.apache.lucene.util.IOUtils;
 
 public class TestLRUQueryCache extends LuceneTestCase {
@@ -356,11 +355,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
 
   // This test makes sure that by making the same assumptions as LRUQueryCache, RAMUsageTester
   // computes the same memory usage.
+  @AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7595")
   public void testRamBytesUsedAgreesWithRamUsageTester() throws IOException {
-    assumeFalse(
-        "LUCENE-7595: RamUsageTester does not work exact in Java 9 (estimations for maps and lists)",
-        Constants.JRE_IS_MINIMUM_JAVA9);
-
     final LRUQueryCache queryCache =
         new LRUQueryCache(
             1 + random().nextInt(5),
@@ -496,11 +492,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
   // that require very little memory. In that case most of the memory is taken
   // by the cache itself, not cache entries, and we want to make sure that
   // memory usage is not grossly underestimated.
+  @AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7595")
   public void testRamBytesUsedConstantEntryOverhead() throws IOException {
-    assumeFalse(
-        "LUCENE-7595: RamUsageTester does not work exact in Java 9 (estimations for maps and lists)",
-        Constants.JRE_IS_MINIMUM_JAVA9);
-
     final LRUQueryCache queryCache =
         new LRUQueryCache(1000000, 10000000, context -> true, Float.POSITIVE_INFINITY);
 
@@ -1171,10 +1164,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
     }
   }
 
+  @AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7604")
   public void testDetectMutatedQueries() throws IOException {
-    LuceneTestCase.assumeFalse(
-        "LUCENE-7604: For some unknown reason the non-constant BadQuery#hashCode() does not trigger ConcurrentModificationException on Java 9 b150",
-        Constants.JRE_IS_MINIMUM_JAVA9);
     Directory dir = newDirectory();
     final RandomIndexWriter w = new RandomIndexWriter(random(), dir);
     w.addDocument(new Document());

lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseTestCheckIndex.java

@@ -92,7 +92,6 @@ public class BaseTestCheckIndex extends LuceneTestCase {
     assertEquals(18, seg.termVectorStatus.docCount);
     assertEquals(18, seg.termVectorStatus.totVectors);
 
-    assertNotNull(seg.diagnostics.get("java.vm.version"));
     assertNotNull(seg.diagnostics.get("java.runtime.version"));
 
     assertTrue(seg.diagnostics.size() > 0);

lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.java

@@ -48,7 +48,6 @@ import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
 import com.carrotsearch.randomizedtesting.generators.RandomPicks;
 import com.carrotsearch.randomizedtesting.rules.NoClassHooksShadowingRule;
 import com.carrotsearch.randomizedtesting.rules.NoInstanceHooksOverridesRule;
-import com.carrotsearch.randomizedtesting.rules.StaticFieldsInvariantRule;
 import java.io.Closeable;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -83,7 +82,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -611,24 +609,6 @@ public abstract class LuceneTestCase extends Assert {
     return ignoreAfterMaxFailuresDelegate.getAndSet(newValue);
   }
 
-  /**
-   * Max 10mb of static data stored in a test suite class after the suite is complete. Prevents
-   * static data structures leaking and causing OOMs in subsequent tests.
-   */
-  private static final long STATIC_LEAK_THRESHOLD = 10 * 1024 * 1024;
-
-  /** By-name list of ignored types like loggers etc. */
-  private static final Set<String> STATIC_LEAK_IGNORED_TYPES =
-      Set.of(
-          "org.slf4j.Logger",
-          "org.apache.solr.SolrLogFormatter",
-          "java.io.File", // Solr sometimes refers to this in a static way, but it has a
-          // "java.nio.fs.Path" inside
-          Path.class
-              .getName(), // causes problems because interface is implemented by hidden classes
-          Class.class.getName(),
-          EnumSet.class.getName());
-
   /**
    * This controls how suite-level rules are nested. It is important that _all_ rules declared in
    * {@link LuceneTestCase} are executed in proper order if they depend on each other.
@@ -646,26 +626,6 @@ public abstract class LuceneTestCase extends Assert {
             .around(new TestRuleAssertionsRequired())
             .around(new TestRuleLimitSysouts(suiteFailureMarker))
             .around(tempFilesCleanupRule = new TestRuleTemporaryFilesCleanup(suiteFailureMarker));
-    // TODO LUCENE-7595: Java 9 does not allow to look into runtime classes, so we have to fix the
-    // RAM usage checker!
-    if (!Constants.JRE_IS_MINIMUM_JAVA9) {
-      r =
-          r.around(
-              new StaticFieldsInvariantRule(STATIC_LEAK_THRESHOLD, true) {
-                @Override
-                protected boolean accept(java.lang.reflect.Field field) {
-                  // Don't count known classes that consume memory once.
-                  if (STATIC_LEAK_IGNORED_TYPES.contains(field.getType().getName())) {
-                    return false;
-                  }
-                  // Don't count references from ourselves, we're top-level.
-                  if (field.getDeclaringClass() == LuceneTestCase.class) {
-                    return false;
-                  }
-                  return super.accept(field);
-                }
-              });
-    }
     classRules =
         r.around(new NoClassHooksShadowingRule())
             .around(

lucene/test-framework/src/java/org/apache/lucene/tests/util/RamUsageTester.java

@@ -44,7 +44,6 @@ import java.util.function.ToLongFunction;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
-import org.apache.lucene.util.Constants;
 import org.apache.lucene.util.RamUsageEstimator;
 import org.apache.lucene.util.SuppressForbidden;
 
@@ -170,49 +169,44 @@ public final class RamUsageTester {
      * and accumulate this object's shallow size.
      */
     try {
-      if (Constants.JRE_IS_MINIMUM_JAVA9) {
+      long alignedShallowInstanceSize = RamUsageEstimator.shallowSizeOf(ob);
-        long alignedShallowInstanceSize = RamUsageEstimator.shallowSizeOf(ob);
 
-        Predicate<Class<?>> isJavaModule = (clazz) -> clazz.getName().startsWith("java.");
+      Predicate<Class<?>> isJavaModule = (clazz) -> clazz.getName().startsWith("java.");
 
-        // Java 9: Best guess for some known types, as we cannot precisely look into runtime
+      // Java 9+: Best guess for some known types, as we cannot precisely look into runtime
-        // classes:
+      // classes:
-        final ToLongFunction<Object> func = SIMPLE_TYPES.get(obClazz);
+      final ToLongFunction<Object> func = SIMPLE_TYPES.get(obClazz);
-        if (func
+      if (func != null) { // some simple type like String where the size is easy to get from public
-            != null) { // some simple type like String where the size is easy to get from public
+        // properties
-          // properties
+        return accumulator.accumulateObject(
-          return accumulator.accumulateObject(
+            ob, alignedShallowInstanceSize + func.applyAsLong(ob), Collections.emptyMap(), stack);
-              ob, alignedShallowInstanceSize + func.applyAsLong(ob), Collections.emptyMap(), stack);
+      } else if (ob instanceof Enum) {
-        } else if (ob instanceof Enum) {
+        return alignedShallowInstanceSize;
-          return alignedShallowInstanceSize;
+      } else if (ob instanceof ByteBuffer) {
-        } else if (ob instanceof ByteBuffer) {
+        // Approximate ByteBuffers with their underlying storage (ignores field overhead).
-          // Approximate ByteBuffers with their underlying storage (ignores field overhead).
+        return byteArraySize(((ByteBuffer) ob).capacity());
-          return byteArraySize(((ByteBuffer) ob).capacity());
+      } else if (isJavaModule.test(obClazz) && ob instanceof Map) {
-        } else if (isJavaModule.test(obClazz) && ob instanceof Map) {
+        final List<Object> values =
-          final List<Object> values =
+            ((Map<?, ?>) ob)
-              ((Map<?, ?>) ob)
+                .entrySet().stream()
-                  .entrySet().stream()
+                    .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
-                      .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
+                    .collect(Collectors.toList());
-                      .collect(Collectors.toList());
+        return accumulator.accumulateArray(
-          return accumulator.accumulateArray(
+                ob,
-                  ob,
+                alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
-                  alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
+                values,
-                  values,
+                stack)
-                  stack)
+            + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
-              + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
+      } else if (isJavaModule.test(obClazz) && ob instanceof Iterable) {
-        } else if (isJavaModule.test(obClazz) && ob instanceof Iterable) {
+        final List<Object> values =
-          final List<Object> values =
+            StreamSupport.stream(((Iterable<?>) ob).spliterator(), false)
-              StreamSupport.stream(((Iterable<?>) ob).spliterator(), false)
+                .collect(Collectors.toList());
-                  .collect(Collectors.toList());
+        return accumulator.accumulateArray(
-          return accumulator.accumulateArray(
+                ob,
-                  ob,
+                alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
-                  alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
+                values,
-                  values,
+                stack)
-                  stack)
+            + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
-              + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
-        } else {
-          // Fallback to reflective access.
-        }
       }
 
       ClassCache cachedInfo = classCache.get(obClazz);