Missing files added

Author: robsunday

instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/unit/UnitConverter.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.jmx.engine.unit;
+
+import java.util.function.Function;
+
+/** This class is responsible for converting a value using provided algorithm. */
+public class UnitConverter {
+  private final Function<Number, Number> convertingFunction;
+  private final boolean convertToDouble;
+
+  /**
+   * Create an instance of converter
+   *
+   * @param convertingFunction an algorithm applied when converting value
+   * @param convertToDouble indicates of algorithm will return floating point result. This must be
+   *     in-sync with algorithm implementation.
+   */
+  UnitConverter(Function<Number, Number> convertingFunction, boolean convertToDouble) {
+    this.convertingFunction = convertingFunction;
+    this.convertToDouble = convertToDouble;
+  }
+
+  public Number convert(Number value) {
+    return convertingFunction.apply(value);
+  }
+
+  public boolean isConvertingToDouble() {
+    return convertToDouble;
+  }
+}

instrumentation/jmx-metrics/library/src/main/java/io/opentelemetry/instrumentation/jmx/engine/unit/UnitConverterFactory.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.jmx.engine.unit;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+public class UnitConverterFactory {
+
+  private static final Map<String, Map<String, UnitConverter>> conversionMappings = new HashMap<>();
+
+  static {
+    registerConverter("ms", "s", value -> value.doubleValue() / TimeUnit.SECONDS.toMillis(1), true);
+    registerConverter("ns", "s", value -> value.doubleValue() / TimeUnit.SECONDS.toNanos(1), true);
+  }
+
+  private UnitConverterFactory() {}
+
+  public static UnitConverter getConverter(@Nullable String fromUnit, @Nullable String toUnit) {
+    if (fromUnit == null || toUnit == null) {
+      return null;
+    }
+
+    Map<String, UnitConverter> converters = conversionMappings.get(fromUnit);
+    if (converters == null) {
+      return null;
+    }
+
+    return converters.get(toUnit);
+  }
+
+  public static void registerConverter(
+      String sourceUnit,
+      String targetUnit,
+      Function<Number, Number> convertingFunction,
+      boolean convertToDouble) {
+    Map<String, UnitConverter> converters =
+        conversionMappings.computeIfAbsent(sourceUnit, k -> new HashMap<>());
+
+    if (converters.containsKey(targetUnit)) {
+      throw new IllegalArgumentException(
+          "Converter from " + sourceUnit + " to " + targetUnit + " already registered");
+    }
+    converters.put(targetUnit, new UnitConverter(convertingFunction, convertToDouble));
+  }
+}

instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/unit/UnitConverterFactoryTest.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.jmx.engine.unit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class UnitConverterFactoryTest {
+
+  @ParameterizedTest
+  @CsvSource({
+    "1000000000,ns, 1.0",
+    "25,ns, 0.000000025",
+    "96614101945,ns, 96.614101945",
+    "0,ns, 0",
+    "1000,ms, 1.0",
+    "25,ms, 0.025",
+    "9661410,ms, 9661.41",
+    "0,ms, 0",
+  })
+  void shouldSupportPredefined_to_s_Converters(
+      Long originalValue, String originalUnit, Double expectedConvertedValue) {
+    // Given
+    String targetUnit = "s";
+
+    // When
+    UnitConverter converter = UnitConverterFactory.getConverter(originalUnit, targetUnit);
+    Number actualValue = converter.convert(originalValue);
+
+    // Then
+    assertEquals(expectedConvertedValue, actualValue);
+    assertTrue(converter.isConvertingToDouble());
+  }
+
+  @Test
+  void shouldSupportCustomConverter() {
+    // Given
+    String sourceUnit = "MB";
+    String targetUnit = "By";
+
+    // When
+    UnitConverterFactory.registerConverter(
+        sourceUnit, targetUnit, (megaBytes) -> megaBytes.doubleValue() * 1024 * 1024, false);
+    UnitConverter converter = UnitConverterFactory.getConverter(sourceUnit, targetUnit);
+    Number actualValue = converter.convert(1.5);
+
+    // Then
+    assertEquals(1572864, actualValue.longValue());
+    assertFalse(converter.isConvertingToDouble());
+  }
+
+  @ParameterizedTest
+  @MethodSource("provideUnitsForMissingConverter")
+  void shouldHandleMissingConverter(String sourceUnit, String targetUnit) {
+    UnitConverter converter = UnitConverterFactory.getConverter(sourceUnit, targetUnit);
+    assertNull(converter);
+  }
+
+  private static Stream<Arguments> provideUnitsForMissingConverter() {
+    return Stream.of(
+        Arguments.of(null, null),
+        Arguments.of("ms", null),
+        Arguments.of("ms", ""),
+        Arguments.of("ms", "--"),
+        Arguments.of("--", "--"));
+  }
+}