feat: Cache OpenTelemetry metric instruments (#256)

## Summary
This change introduces caching for OpenTelemetry metric instruments
(Gauge, Counter, Histogram, UpDownCounter) within the
`InstrumentationManager`.

Previously, a new instrument was built for every metric recording call
(`recordMetric`, `recordCount`, etc.), which is inefficient. Now,
instruments are created once per metric name and reused for subsequent
calls, improving performance.

## How did you test this change?
--

## Are there any deployment considerations?
No

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Caches OTEL metric instruments in `InstrumentationManager` and reuses
them per metric name instead of rebuilding on each call.
> 
> - **Metrics caching in
`sdk/@launchdarkly/observability-android/.../InstrumentationManager.kt`**:
> - Add caches for instruments: `gaugeCache`, `counterCache`,
`histogramCache`, `upDownCounterCache` using `ConcurrentHashMap`.
> - Import instrument types (`DoubleGauge`, `LongCounter`,
`DoubleHistogram`, `LongUpDownCounter`) and `ConcurrentHashMap`.
> - Update `recordMetric`, `recordCount`, `recordIncr`,
`recordHistogram`, `recordUpDownCounter` to `getOrPut` and reuse
instruments by name.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
6888028. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: agrognetti

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/client/InstrumentationManager.kt

@@ -18,6 +18,10 @@ import io.opentelemetry.android.session.SessionConfig
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.logs.Logger
 import io.opentelemetry.api.logs.Severity
+import io.opentelemetry.api.metrics.DoubleGauge
+import io.opentelemetry.api.metrics.DoubleHistogram
+import io.opentelemetry.api.metrics.LongCounter
+import io.opentelemetry.api.metrics.LongUpDownCounter
 import io.opentelemetry.api.metrics.Meter
 import io.opentelemetry.api.trace.Span
 import io.opentelemetry.api.trace.Tracer
@@ -43,6 +47,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 
 /**
@@ -87,10 +92,13 @@ class InstrumentationManager(
     private var inMemoryLogExporter: InMemoryLogRecordExporter? = null
     private var inMemoryMetricExporter: InMemoryMetricExporter? = null
     private var telemetryInspector: TelemetryInspector? = null
-
     private var spanProcessor: BatchSpanProcessor? = null
     private var logProcessor: BatchLogRecordProcessor? = null
     private var metricsReader: PeriodicMetricReader? = null
+    private val gaugeCache = ConcurrentHashMap<String, DoubleGauge>()
+    private val counterCache = ConcurrentHashMap<String, LongCounter>()
+    private val histogramCache = ConcurrentHashMap<String, DoubleHistogram>()
+    private val upDownCounterCache = ConcurrentHashMap<String, LongUpDownCounter>()
 
     //TODO: Evaluate if this class should have a close/shutdown method to close this scope
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
@@ -275,29 +283,39 @@ class InstrumentationManager(
     }
 
     fun recordMetric(metric: Metric) {
-        otelMeter.gaugeBuilder(metric.name).build()
-            .set(metric.value, metric.attributes)
+        val gauge = gaugeCache.getOrPut(metric.name) {
+            otelMeter.gaugeBuilder(metric.name).build()
+        }
+        gauge.set(metric.value, metric.attributes)
     }
 
     fun recordCount(metric: Metric) {
         // TODO: handle double casting to long better
-        otelMeter.counterBuilder(metric.name).build()
-            .add(metric.value.toLong(), metric.attributes)
+        val counter = counterCache.getOrPut(metric.name) {
+            otelMeter.counterBuilder(metric.name).build()
+        }
+        counter.add(metric.value.toLong(), metric.attributes)
     }
 
     fun recordIncr(metric: Metric) {
-        otelMeter.counterBuilder(metric.name).build()
-            .add(1, metric.attributes)
+        val counter = counterCache.getOrPut(metric.name) {
+            otelMeter.counterBuilder(metric.name).build()
+        }
+        counter.add(1, metric.attributes)
     }
 
     fun recordHistogram(metric: Metric) {
-        otelMeter.histogramBuilder(metric.name).build()
-            .record(metric.value, metric.attributes)
+        val histogram = histogramCache.getOrPut(metric.name) {
+            otelMeter.histogramBuilder(metric.name).build()
+        }
+        histogram.record(metric.value, metric.attributes)
     }
 
     fun recordUpDownCounter(metric: Metric) {
-        otelMeter.upDownCounterBuilder(metric.name).build()
-            .add(metric.value.toLong(), metric.attributes)
+        val upDownCounter = upDownCounterCache.getOrPut(metric.name) {
+            otelMeter.upDownCounterBuilder(metric.name).build()
+        }
+        upDownCounter.add(metric.value.toLong(), metric.attributes)
     }
 
     fun recordLog(message: String, severity: Severity, attributes: Attributes) {