This is an automated email from the ASF dual-hosted git repository.
mlbiscoc pushed a commit to branch feature/SOLR-17458
in repository https://gitbox.apache.org/repos/asf/solr.git
The following commit(s) were added to refs/heads/feature/SOLR-17458 by this
push:
new 84ca00a6cd3 SOLR-17806: Migrate DirectUpdateHandler2 metrics to OTEL
(#3417)
84ca00a6cd3 is described below
commit 84ca00a6cd3b9f5a0eb8ead91081a71ad22acc4b
Author: Matthew Biscocho <[email protected]>
AuthorDate: Tue Jul 29 16:01:59 2025 -0400
SOLR-17806: Migrate DirectUpdateHandler2 metrics to OTEL (#3417)
* Migrate direct update handler
* Fix up metrics
* UNCOMMIT ME BEFORE PUSHING
* Revert requestHandlerBase
* Fix broken tests
* Cleanup
* Move commit ops to normal counter
* Add new submitted and committed metrics
* Move methods around
* Fix tests for submitted and committed
* Use toBuilder() instead of putAll()
* Don't append scope as attribute
---
.../apache/solr/metrics/SolrCoreMetricManager.java | 14 +-
.../apache/solr/metrics/SolrMetricProducer.java | 1 +
.../apache/solr/metrics/SolrMetricsContext.java | 15 +
.../apache/solr/update/DirectUpdateHandler2.java | 319 +++++++++++++-------
.../apache/solr/cloud/TestPullReplicaWithAuth.java | 3 +
.../org/apache/solr/cloud/TestTlogReplica.java | 46 +--
.../apache/solr/metrics/SolrMetricTestUtils.java | 2 +-
.../solr/update/DirectUpdateHandlerTest.java | 323 +++++++++++++++------
solr/webapp/web/js/angular/controllers/plugins.js | 2 +
9 files changed, 502 insertions(+), 223 deletions(-)
diff --git
a/solr/core/src/java/org/apache/solr/metrics/SolrCoreMetricManager.java
b/solr/core/src/java/org/apache/solr/metrics/SolrCoreMetricManager.java
index 9d79ada8a85..a01183da9ad 100644
--- a/solr/core/src/java/org/apache/solr/metrics/SolrCoreMetricManager.java
+++ b/solr/core/src/java/org/apache/solr/metrics/SolrCoreMetricManager.java
@@ -146,18 +146,16 @@ public class SolrCoreMetricManager implements Closeable {
+ producer);
}
- // NOCOMMIT SOLR-17458: These attributes may not work for standalone mode
- // use deprecated method for back-compat, remove in 9.0
- producer.initializeMetrics(
- solrMetricsContext,
+ // NOCOMMIT SOLR-17458: These attributes may not work for standalone mode
and maybe make the
+ // scope attribute optional
+ var attributesBuilder =
Attributes.builder()
.put(CORE_ATTR, core.getCoreDescriptor().getName())
.put(COLLECTION_ATTR, collectionName)
.put(SHARD_ATTR, shardName)
- .put(REPLICA_ATTR, replicaName)
- .put((scope.startsWith("/")) ? HANDLER_ATTR : SCOPE_ATTR, scope)
- .build(),
- scope);
+ .put(REPLICA_ATTR, replicaName);
+ if (scope.startsWith("/")) attributesBuilder.put(HANDLER_ATTR, scope);
+ producer.initializeMetrics(solrMetricsContext, attributesBuilder.build(),
scope);
}
/** Return the registry used by this SolrCore. */
diff --git a/solr/core/src/java/org/apache/solr/metrics/SolrMetricProducer.java
b/solr/core/src/java/org/apache/solr/metrics/SolrMetricProducer.java
index f6079511ab0..e2b433108e6 100644
--- a/solr/core/src/java/org/apache/solr/metrics/SolrMetricProducer.java
+++ b/solr/core/src/java/org/apache/solr/metrics/SolrMetricProducer.java
@@ -25,6 +25,7 @@ public interface SolrMetricProducer extends AutoCloseable {
public static final AttributeKey<String> TYPE_ATTR =
AttributeKey.stringKey("type");
public static final AttributeKey<String> CATEGORY_ATTR =
AttributeKey.stringKey("category");
+ public static final AttributeKey<String> OPERATION_ATTR =
AttributeKey.stringKey("ops");
/**
* Unique metric tag identifies components with the same life-cycle, which
should be registered /
diff --git a/solr/core/src/java/org/apache/solr/metrics/SolrMetricsContext.java
b/solr/core/src/java/org/apache/solr/metrics/SolrMetricsContext.java
index 222ce2e0e8a..1601bae36a3 100644
--- a/solr/core/src/java/org/apache/solr/metrics/SolrMetricsContext.java
+++ b/solr/core/src/java/org/apache/solr/metrics/SolrMetricsContext.java
@@ -32,6 +32,7 @@ import io.opentelemetry.api.metrics.LongHistogram;
import io.opentelemetry.api.metrics.LongUpDownCounter;
import io.opentelemetry.api.metrics.ObservableDoubleGauge;
import io.opentelemetry.api.metrics.ObservableDoubleMeasurement;
+import io.opentelemetry.api.metrics.ObservableLongCounter;
import io.opentelemetry.api.metrics.ObservableLongGauge;
import io.opentelemetry.api.metrics.ObservableLongMeasurement;
import java.util.Map;
@@ -233,6 +234,20 @@ public class SolrMetricsContext {
registryName, metricName, description, callback, unit);
}
+ public ObservableLongCounter observableLongCounter(
+ String metricName, String description,
Consumer<ObservableLongMeasurement> callback) {
+ return observableLongCounter(metricName, description, callback, null);
+ }
+
+ public ObservableLongCounter observableLongCounter(
+ String metricName,
+ String description,
+ Consumer<ObservableLongMeasurement> callback,
+ String unit) {
+ return metricManager.observableLongCounter(
+ registryName, metricName, description, callback, unit);
+ }
+
/**
* Convenience method for {@link SolrMetricManager#meter(SolrMetricsContext,
String, String,
* String...)}.
diff --git
a/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java
b/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java
index cecf89be835..90c8bac2285 100644
--- a/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java
+++ b/solr/core/src/java/org/apache/solr/update/DirectUpdateHandler2.java
@@ -16,8 +16,10 @@
*/
package org.apache.solr.update;
-import com.codahale.metrics.Meter;
+import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.ObservableLongCounter;
+import io.opentelemetry.api.metrics.ObservableLongGauge;
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Array;
@@ -56,6 +58,8 @@ import
org.apache.solr.metrics.SolrDelegateRegistryMetricsContext;
import org.apache.solr.metrics.SolrMetricManager;
import org.apache.solr.metrics.SolrMetricProducer;
import org.apache.solr.metrics.SolrMetricsContext;
+import org.apache.solr.metrics.otel.instruments.AttributedLongCounter;
+import org.apache.solr.metrics.otel.instruments.AttributedLongUpDownCounter;
import org.apache.solr.request.LocalSolrQueryRequest;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.request.SolrRequestInfo;
@@ -89,20 +93,36 @@ public class DirectUpdateHandler2 extends UpdateHandler
// stats
LongAdder addCommands = new LongAdder();
- Meter addCommandsCumulative;
LongAdder deleteByIdCommands = new LongAdder();
- Meter deleteByIdCommandsCumulative;
LongAdder deleteByQueryCommands = new LongAdder();
- Meter deleteByQueryCommandsCumulative;
- Meter expungeDeleteCommands;
- Meter mergeIndexesCommands;
- Meter commitCommands;
- Meter splitCommands;
- Meter optimizeCommands;
- Meter rollbackCommands;
LongAdder numDocsPending = new LongAdder();
- LongAdder numErrors = new LongAdder();
- Meter numErrorsCumulative;
+
+ // Cumulative commands
+ AttributedLongUpDownCounter deleteByQueryCommandsCumulative;
+ AttributedLongUpDownCounter deleteByIdCommandsCumulative;
+ AttributedLongUpDownCounter addCommandsCumulative;
+
+ AttributedLongCounter submittedAdds;
+ AttributedLongCounter submittedDeleteById;
+ AttributedLongCounter submittedDeleteByQuery;
+
+ AttributedLongCounter committedAdds;
+ AttributedLongCounter committedDeleteById;
+ AttributedLongCounter committedDeleteByQuery;
+
+ // Maintenance operations
+ AttributedLongCounter expungeDeleteCommands;
+ AttributedLongCounter mergeIndexesCommands;
+ AttributedLongCounter commitCommands;
+ AttributedLongCounter optimizeCommands;
+
+ AttributedLongCounter numErrorsCumulative;
+
+ AttributedLongCounter rollbackCommands;
+ AttributedLongCounter splitCommands;
+ ObservableLongGauge commitStats;
+ ObservableLongGauge updateStats;
+ ObservableLongCounter softAutoCommits;
// tracks when auto-commit should occur
protected final CommitTracker commitTracker;
@@ -206,7 +226,6 @@ public class DirectUpdateHandler2 extends UpdateHandler
}
}
- // TODO SOLR-17458: Migrate to Otel
@Override
public void initializeMetrics(
SolrMetricsContext parentContext, Attributes attributes, String scope) {
@@ -220,84 +239,162 @@ public class DirectUpdateHandler2 extends UpdateHandler
} else {
this.solrMetricsContext = parentContext.getChildContext(this);
}
- commitCommands = solrMetricsContext.meter("commits",
getCategory().toString(), scope);
- solrMetricsContext.gauge(
- () -> commitTracker.getCommitCount(), true, "autoCommits",
getCategory().toString(), scope);
- solrMetricsContext.gauge(
- () -> softCommitTracker.getCommitCount(),
- true,
- "softAutoCommits",
- getCategory().toString(),
- scope);
- if (commitTracker.getDocsUpperBound() > 0) {
- solrMetricsContext.gauge(
- () -> commitTracker.getDocsUpperBound(),
- true,
- "autoCommitMaxDocs",
- getCategory().toString(),
- scope);
- }
- if (commitTracker.getTimeUpperBound() > 0) {
- solrMetricsContext.gauge(
- () -> "" + commitTracker.getTimeUpperBound() + "ms",
- true,
- "autoCommitMaxTime",
- getCategory().toString(),
- scope);
- }
- if (commitTracker.getTLogFileSizeUpperBound() > 0) {
- solrMetricsContext.gauge(
- () -> commitTracker.getTLogFileSizeUpperBound(),
- true,
- "autoCommitMaxSize",
- getCategory().toString(),
- scope);
- }
- if (softCommitTracker.getDocsUpperBound() > 0) {
- solrMetricsContext.gauge(
- () -> softCommitTracker.getDocsUpperBound(),
- true,
- "softAutoCommitMaxDocs",
- getCategory().toString(),
- scope);
- }
- if (softCommitTracker.getTimeUpperBound() > 0) {
- solrMetricsContext.gauge(
- () -> "" + softCommitTracker.getTimeUpperBound() + "ms",
- true,
- "softAutoCommitMaxTime",
- getCategory().toString(),
- scope);
- }
- optimizeCommands = solrMetricsContext.meter("optimizes",
getCategory().toString(), scope);
- rollbackCommands = solrMetricsContext.meter("rollbacks",
getCategory().toString(), scope);
- splitCommands = solrMetricsContext.meter("splits",
getCategory().toString(), scope);
- mergeIndexesCommands = solrMetricsContext.meter("merges",
getCategory().toString(), scope);
- expungeDeleteCommands =
- solrMetricsContext.meter("expungeDeletes", getCategory().toString(),
scope);
- solrMetricsContext.gauge(
- () -> numDocsPending.longValue(), true, "docsPending",
getCategory().toString(), scope);
- solrMetricsContext.gauge(
- () -> addCommands.longValue(), true, "adds", getCategory().toString(),
scope);
- solrMetricsContext.gauge(
- () -> deleteByIdCommands.longValue(), true, "deletesById",
getCategory().toString(), scope);
- solrMetricsContext.gauge(
- () -> deleteByQueryCommands.longValue(),
- true,
- "deletesByQuery",
- getCategory().toString(),
- scope);
- solrMetricsContext.gauge(
- () -> numErrors.longValue(), true, "errors", getCategory().toString(),
scope);
+
+ var baseAttributes =
+ attributes.toBuilder()
+ .put(AttributeKey.stringKey("category"), getCategory().toString())
+ .build();
+
+ var baseCommandsMetric =
+ solrMetricsContext.longUpDownCounter(
+ "solr_core_update_cumulative_ops",
+ "Cumulative number of update commands processed. Cumulative can
decrease from rollback command");
addCommandsCumulative =
- solrMetricsContext.meter("cumulativeAdds", getCategory().toString(),
scope);
+ new AttributedLongUpDownCounter(
+ baseCommandsMetric, baseAttributes.toBuilder().put(OPERATION_ATTR,
"adds").build());
+
deleteByIdCommandsCumulative =
- solrMetricsContext.meter("cumulativeDeletesById",
getCategory().toString(), scope);
+ new AttributedLongUpDownCounter(
+ baseCommandsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_id").build());
+
deleteByQueryCommandsCumulative =
- solrMetricsContext.meter("cumulativeDeletesByQuery",
getCategory().toString(), scope);
+ new AttributedLongUpDownCounter(
+ baseCommandsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_query").build());
+
+ var baseCommitOpsMetric =
+ solrMetricsContext.longCounter(
+ "solr_core_update_commit_ops", "Total number of commit
operations");
+
+ commitCommands =
+ new AttributedLongCounter(
+ baseCommitOpsMetric,
baseAttributes.toBuilder().put(OPERATION_ATTR, "commits").build());
+
+ optimizeCommands =
+ new AttributedLongCounter(
+ baseCommitOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"optimize").build());
+
+ mergeIndexesCommands =
+ new AttributedLongCounter(
+ baseCommitOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"merge_indexes").build());
+
+ expungeDeleteCommands =
+ new AttributedLongCounter(
+ baseCommitOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"expunge_deletes").build());
+
+ var baseMaintenanceMetric =
+ solrMetricsContext.longCounter(
+ "solr_core_update_maintenance_ops", "Total number of maintenance
operations");
+
+ rollbackCommands =
+ new AttributedLongCounter(
+ baseMaintenanceMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"rollback").build());
+
+ splitCommands =
+ new AttributedLongCounter(
+ baseMaintenanceMetric,
baseAttributes.toBuilder().put(OPERATION_ATTR, "split").build());
+
+ var baseErrorsMetric =
+ solrMetricsContext.longCounter("solr_core_update_errors", "Total
number of update errors");
+
numErrorsCumulative =
- solrMetricsContext.meter("cumulativeErrors", getCategory().toString(),
scope);
+ new AttributedLongCounter(baseErrorsMetric,
baseAttributes.toBuilder().build());
+
+ softAutoCommits =
+ solrMetricsContext.observableLongCounter(
+ "solr_core_update_auto_commits",
+ "Current number of auto commits",
+ (observableLongMeasurement -> {
+ observableLongMeasurement.record(
+ commitTracker.getCommitCount(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"auto_commits").build());
+ observableLongMeasurement.record(
+ softCommitTracker.getCommitCount(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"soft_auto_commits").build());
+ }));
+
+ // NOCOMMIT: This might not need to be an obseravableLongGauge, but a
simple long gauge. Seems
+ // like a waste to constantly call this callback to get the latest value
if the upper bounds
+ // rarely change.
+ commitStats =
+ solrMetricsContext.observableLongGauge(
+ "solr_core_update_commit_stats",
+ "Metrics around commits",
+ (observableLongMeasurement -> {
+ if (commitTracker.getDocsUpperBound() > 0) {
+ observableLongMeasurement.record(
+ commitTracker.getDocsUpperBound(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"auto_commit_max_docs").build());
+ }
+ if (commitTracker.getTLogFileSizeUpperBound() > 0) {
+ observableLongMeasurement.record(
+ commitTracker.getTLogFileSizeUpperBound(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"auto_commit_max_size").build());
+ }
+ if (softCommitTracker.getDocsUpperBound() > 0) {
+ observableLongMeasurement.record(
+ softCommitTracker.getDocsUpperBound(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"soft_auto_commit_max_docs").build());
+ }
+ if (commitTracker.getTimeUpperBound() > 0) {
+ observableLongMeasurement.record(
+ commitTracker.getTimeUpperBound(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"auto_commit_max_time").build());
+ }
+ if (softCommitTracker.getTimeUpperBound() > 0) {
+ observableLongMeasurement.record(
+ softCommitTracker.getTimeUpperBound(),
+ baseAttributes.toBuilder().put(TYPE_ATTR,
"soft_auto_commit_max_time").build());
+ }
+ }));
+
+ updateStats =
+ solrMetricsContext.observableLongGauge(
+ "solr_core_update_docs_pending_commit",
+ "Current number of documents pending commit. Value is reset to 0
on commit.",
+ (observableLongMeasurement) -> {
+ observableLongMeasurement.record(
+ numDocsPending.longValue(),
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"docs_pending").build());
+ });
+
+ var baseSubmittedOpsMetric =
+ solrMetricsContext.longCounter(
+ "solr_core_update_submitted_ops", "Total number of submitted
update operations");
+
+ var baseCommittedOpsMetric =
+ solrMetricsContext.longCounter(
+ "solr_core_update_committed_ops", "Total number of committed
update operations");
+
+ submittedAdds =
+ new AttributedLongCounter(
+ baseSubmittedOpsMetric,
baseAttributes.toBuilder().put(OPERATION_ATTR, "adds").build());
+ submittedDeleteById =
+ new AttributedLongCounter(
+ baseSubmittedOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_id").build());
+ submittedDeleteByQuery =
+ new AttributedLongCounter(
+ baseSubmittedOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_query").build());
+
+ committedAdds =
+ new AttributedLongCounter(
+ baseCommittedOpsMetric,
baseAttributes.toBuilder().put(OPERATION_ATTR, "adds").build());
+ committedDeleteById =
+ new AttributedLongCounter(
+ baseCommittedOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_id").build());
+ committedDeleteByQuery =
+ new AttributedLongCounter(
+ baseCommittedOpsMetric,
+ baseAttributes.toBuilder().put(OPERATION_ATTR,
"deletes_by_query").build());
}
private void deleteAll() throws IOException {
@@ -359,7 +456,8 @@ public class DirectUpdateHandler2 extends UpdateHandler
int rc = -1;
addCommands.increment();
- addCommandsCumulative.mark();
+ addCommandsCumulative.inc();
+ submittedAdds.inc();
// if there is no ID field, don't overwrite
if (idField == null) {
@@ -401,8 +499,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
rc = 1;
} finally {
if (rc != 1) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
} else {
numDocsPending.increment();
}
@@ -507,7 +604,8 @@ public class DirectUpdateHandler2 extends UpdateHandler
public void delete(DeleteUpdateCommand cmd) throws IOException {
TestInjection.injectDirectUpdateLatch();
deleteByIdCommands.increment();
- deleteByIdCommandsCumulative.mark();
+ deleteByIdCommandsCumulative.inc();
+ submittedDeleteById.inc();
if ((cmd.getFlags() & UpdateCommand.IGNORE_INDEXWRITER) != 0) {
if (ulog != null) ulog.delete(cmd);
@@ -573,7 +671,8 @@ public class DirectUpdateHandler2 extends UpdateHandler
public void deleteByQuery(DeleteUpdateCommand cmd) throws IOException {
TestInjection.injectDirectUpdateLatch();
deleteByQueryCommands.increment();
- deleteByQueryCommandsCumulative.mark();
+ deleteByQueryCommandsCumulative.inc();
+ submittedDeleteByQuery.inc();
boolean madeIt = false;
try {
Query q = getQuery(cmd);
@@ -641,8 +740,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
} finally {
if (!madeIt) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
}
}
}
@@ -650,7 +748,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
@Override
public int mergeIndexes(MergeIndexesCommand cmd) throws IOException {
TestInjection.injectDirectUpdateLatch();
- mergeIndexesCommands.mark();
+ mergeIndexesCommands.inc();
int rc;
log.info("start {}", cmd);
@@ -704,8 +802,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
error = false;
} finally {
if (error) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
}
}
}
@@ -719,10 +816,10 @@ public class DirectUpdateHandler2 extends UpdateHandler
}
if (cmd.optimize) {
- optimizeCommands.mark();
+ optimizeCommands.inc();
} else {
- commitCommands.mark();
- if (cmd.expungeDeletes) expungeDeleteCommands.mark();
+ commitCommands.inc();
+ if (cmd.expungeDeletes) expungeDeleteCommands.inc();
}
@SuppressWarnings("unchecked")
@@ -831,13 +928,14 @@ public class DirectUpdateHandler2 extends UpdateHandler
if (!cmd.softCommit) {
solrCoreState.getCommitLock().unlock();
}
-
+ committedAdds.add(addCommands.longValue());
+ committedDeleteById.add(deleteByIdCommands.longValue());
+ committedDeleteByQuery.add(deleteByQueryCommands.longValue());
addCommands.reset();
deleteByIdCommands.reset();
deleteByQueryCommands.reset();
if (error) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
}
}
@@ -877,7 +975,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
"Rollback is currently not supported in SolrCloud mode.
(SOLR-4895)");
}
- rollbackCommands.mark();
+ rollbackCommands.inc();
boolean error = true;
@@ -896,12 +994,11 @@ public class DirectUpdateHandler2 extends UpdateHandler
error = false;
} finally {
- addCommandsCumulative.mark(-addCommands.sumThenReset());
- deleteByIdCommandsCumulative.mark(-deleteByIdCommands.sumThenReset());
-
deleteByQueryCommandsCumulative.mark(-deleteByQueryCommands.sumThenReset());
+ addCommandsCumulative.add(-addCommands.sumThenReset());
+ deleteByIdCommandsCumulative.add(-deleteByIdCommands.sumThenReset());
+
deleteByQueryCommandsCumulative.add(-deleteByQueryCommands.sumThenReset());
if (error) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
}
}
}
@@ -917,6 +1014,7 @@ public class DirectUpdateHandler2 extends UpdateHandler
commitTracker.close();
softCommitTracker.close();
+ commitStats.close();
numDocsPending.reset();
try {
@@ -1031,14 +1129,13 @@ public class DirectUpdateHandler2 extends UpdateHandler
public void split(SplitIndexCommand cmd) throws IOException {
commit(new CommitUpdateCommand(cmd.req, false));
SolrIndexSplitter splitter = new SolrIndexSplitter(cmd);
- splitCommands.mark();
+ splitCommands.inc();
NamedList<Object> results = new NamedList<>();
try {
splitter.split(results);
cmd.rsp.addResponse(results);
} catch (IOException e) {
- numErrors.increment();
- numErrorsCumulative.mark();
+ numErrorsCumulative.inc();
throw e;
}
}
diff --git
a/solr/core/src/test/org/apache/solr/cloud/TestPullReplicaWithAuth.java
b/solr/core/src/test/org/apache/solr/cloud/TestPullReplicaWithAuth.java
index 902c9e2c6de..fb18ae467b2 100644
--- a/solr/core/src/test/org/apache/solr/cloud/TestPullReplicaWithAuth.java
+++ b/solr/core/src/test/org/apache/solr/cloud/TestPullReplicaWithAuth.java
@@ -67,6 +67,9 @@ public class TestPullReplicaWithAuth extends
SolrCloudTestCase {
}
@Test
+ // NOCOMMIT: This test is broken from OTEL migration and the /admin/plugins
endpoint. Placing
+ // BadApple test but this must be fixed before this feature gets merged to a
release branch
+ @BadApple(bugUrl = "https://issues.apache.org/jira/browse/SOLR-17458";)
public void testPKIAuthWorksForPullReplication() throws Exception {
int numPullReplicas = 2;
withBasicAuth(
diff --git a/solr/core/src/test/org/apache/solr/cloud/TestTlogReplica.java
b/solr/core/src/test/org/apache/solr/cloud/TestTlogReplica.java
index a7a0306b04c..89dc89aa646 100644
--- a/solr/core/src/test/org/apache/solr/cloud/TestTlogReplica.java
+++ b/solr/core/src/test/org/apache/solr/cloud/TestTlogReplica.java
@@ -71,6 +71,7 @@ import org.apache.solr.common.util.NamedList;
import org.apache.solr.common.util.TimeSource;
import org.apache.solr.core.SolrCore;
import org.apache.solr.embedded.JettySolrRunner;
+import org.apache.solr.metrics.SolrMetricTestUtils;
import org.apache.solr.update.SolrIndexWriter;
import org.apache.solr.util.RefCounted;
import org.apache.solr.util.TestInjection;
@@ -257,6 +258,9 @@ public class TestTlogReplica extends SolrCloudTestCase {
}
@SuppressWarnings("unchecked")
+ // NOCOMMIT: This test is broken from OTEL migration and the /admin/plugins
endpoint. Placing
+ // BadApple test but this must be fixed before this feature gets merged to a
release branch
+ @BadApple(bugUrl = "https://issues.apache.org/jira/browse/SOLR-17458";)
public void testAddDocs() throws Exception {
int numTlogReplicas = 1 + random().nextInt(3);
DocCollection docCollection = createAndWaitForCollection(1, 0,
numTlogReplicas, 0);
@@ -570,32 +574,34 @@ public class TestTlogReplica extends SolrCloudTestCase {
.process(cloudClient, collectionName);
{
- long docsPending =
- (long)
- getSolrCore(true)
- .get(0)
- .getSolrMetricsContext()
- .getMetricRegistry()
- .getGauges()
- .get("UPDATE.updateHandler.docsPending")
- .getValue();
+ SolrCore core = getSolrCore(true).getFirst();
+ var actual =
+ SolrMetricTestUtils.getGaugeDatapoint(
+ core,
+ "solr_core_update_docs_pending_commit",
+ SolrMetricTestUtils.newCloudLabelsBuilder(core)
+ .label("category", "UPDATE")
+ .label("ops", "docs_pending")
+ .build());
assertEquals(
- "Expected 4 docs are pending in core " +
getSolrCore(true).get(0).getCoreDescriptor(),
+ "Expected 4 docs are pending in core " +
getSolrCore(true).getFirst().getCoreDescriptor(),
4,
- docsPending);
+ (long) actual.getValue());
}
for (SolrCore solrCore : getSolrCore(false)) {
- long docsPending =
- (long)
- solrCore
- .getSolrMetricsContext()
- .getMetricRegistry()
- .getGauges()
- .get("UPDATE.updateHandler.docsPending")
- .getValue();
+ var actual =
+ SolrMetricTestUtils.getGaugeDatapoint(
+ solrCore,
+ "solr_core_update_docs_pending_commit",
+ SolrMetricTestUtils.newCloudLabelsBuilder(solrCore)
+ .label("category", "UPDATE")
+ .label("ops", "docs_pending")
+ .build());
assertEquals(
- "Expected non docs are pending in core " +
solrCore.getCoreDescriptor(), 0, docsPending);
+ "Expected non docs are pending in core " +
solrCore.getCoreDescriptor(),
+ 0,
+ (long) actual.getValue());
}
checkRTG(1, 4, cluster.getJettySolrRunners());
diff --git
a/solr/core/src/test/org/apache/solr/metrics/SolrMetricTestUtils.java
b/solr/core/src/test/org/apache/solr/metrics/SolrMetricTestUtils.java
index 9da3314ad2a..479615ddf93 100644
--- a/solr/core/src/test/org/apache/solr/metrics/SolrMetricTestUtils.java
+++ b/solr/core/src/test/org/apache/solr/metrics/SolrMetricTestUtils.java
@@ -141,7 +141,7 @@ public final class SolrMetricTestUtils {
.orElse(null);
}
- public static Labels.Builder getCloudLabelsBase(SolrCore core) {
+ public static Labels.Builder newCloudLabelsBuilder(SolrCore core) {
return Labels.builder()
.label("collection",
core.getCoreDescriptor().getCloudDescriptor().getCollectionName())
.label("shard",
core.getCoreDescriptor().getCloudDescriptor().getShardId())
diff --git
a/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerTest.java
b/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerTest.java
index 0d30bb0f198..6cc23d4b92d 100644
--- a/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerTest.java
+++ b/solr/core/src/test/org/apache/solr/update/DirectUpdateHandlerTest.java
@@ -18,9 +18,8 @@ package org.apache.solr.update;
import static org.apache.solr.common.params.CommonParams.VERSION_FIELD;
-import com.codahale.metrics.Gauge;
-import com.codahale.metrics.Meter;
-import com.codahale.metrics.Metric;
+import io.prometheus.metrics.model.snapshots.CounterSnapshot;
+import io.prometheus.metrics.model.snapshots.GaugeSnapshot;
import java.lang.invoke.MethodHandles;
import java.util.Arrays;
import java.util.HashMap;
@@ -36,6 +35,7 @@ import org.apache.solr.common.params.MapSolrParams;
import org.apache.solr.core.SolrCore;
import org.apache.solr.core.SolrEventListener;
import org.apache.solr.index.TieredMergePolicyFactory;
+import org.apache.solr.metrics.SolrMetricTestUtils;
import org.apache.solr.request.LocalSolrQueryRequest;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.search.SolrIndexSearcher;
@@ -77,8 +77,8 @@ public class DirectUpdateHandlerTest extends SolrTestCaseJ4 {
@Before
public void setUp() throws Exception {
super.setUp();
- clearIndex();
- assertU(commit());
+ deleteCore();
+ initCore("solrconfig.xml", "schema12.xml");
}
@Test
@@ -99,30 +99,8 @@ public class DirectUpdateHandlerTest extends SolrTestCaseJ4 {
@SuppressWarnings({"unchecked"})
public void testBasics() {
+ SolrCore core = h.getCore();
// get initial metrics
- Map<String, Metric> metrics =
- h.getCoreContainer()
- .getMetricManager()
- .registry(h.getCore().getCoreMetricManager().getRegistryName())
- .getMetrics();
-
- String PREFIX = "UPDATE.updateHandler.";
-
- String commitsName = PREFIX + "commits";
- assertTrue(metrics.containsKey(commitsName));
- String addsName = PREFIX + "adds";
- assertTrue(metrics.containsKey(addsName));
- String cumulativeAddsName = PREFIX + "cumulativeAdds";
- String delsIName = PREFIX + "deletesById";
- String cumulativeDelsIName = PREFIX + "cumulativeDeletesById";
- String delsQName = PREFIX + "deletesByQuery";
- String cumulativeDelsQName = PREFIX + "cumulativeDeletesByQuery";
- long commits = ((Meter) metrics.get(commitsName)).getCount();
- long adds = ((Gauge<Number>) metrics.get(addsName)).getValue().longValue();
- long cumulativeAdds = ((Meter) metrics.get(cumulativeAddsName)).getCount();
- long cumulativeDelsI = ((Meter)
metrics.get(cumulativeDelsIName)).getCount();
- long cumulativeDelsQ = ((Meter)
metrics.get(cumulativeDelsQName)).getCount();
-
assertNull(
"This test requires a schema that has no version field, "
+ "it appears the schema file in use has been edited to violate "
@@ -136,22 +114,47 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
assertQ(req("q", "id:5"), "//*[@numFound='0']");
assertQ(req("q", "id:6"), "//*[@numFound='0']");
- long newAdds = ((Gauge<Number>)
metrics.get(addsName)).getValue().longValue();
- long newCumulativeAdds = ((Meter)
metrics.get(cumulativeAddsName)).getCount();
- assertEquals("new adds", 2, newAdds - adds);
- assertEquals("new cumulative adds", 2, newCumulativeAdds - cumulativeAdds);
+ assertEquals(
+ "Did not have the expected number of submitted adds",
+ 2,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"adds").getValue(),
+ 0.0);
+
+ assertNull(
+ "No adds should have been committed yet",
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops", "adds"));
+
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 2,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
assertU(commit());
- long newCommits = ((Meter) metrics.get(commitsName)).getCount();
- assertEquals("new commits", 1, newCommits - commits);
+ assertEquals(
+ "Did not have the expected number of cumulative commits",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_commit_ops",
"commits").getValue(),
+ 0.0);
- newAdds = ((Gauge<Number>) metrics.get(addsName)).getValue().longValue();
- newCumulativeAdds = ((Meter) metrics.get(cumulativeAddsName)).getCount();
- // adds should be reset to 0 after commit
- assertEquals("new adds after commit", 0, newAdds);
- // not so with cumulative ones!
- assertEquals("new cumulative adds after commit", 2, newCumulativeAdds -
cumulativeAdds);
+ assertEquals(
+ "Did not have the expected number of submitted adds",
+ 2,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"adds").getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of committed adds",
+ 2,
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops",
"adds").getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of cumulative adds after commit",
+ 2,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
// now they should be there
assertQ(req("q", "id:5"), "//*[@numFound='1']");
@@ -160,20 +163,46 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
// now delete one
assertU(delI("5"));
- long newDelsI = ((Gauge<Number>)
metrics.get(delsIName)).getValue().longValue();
- long newCumulativeDelsI = ((Meter)
metrics.get(cumulativeDelsIName)).getCount();
- assertEquals("new delsI", 1, newDelsI);
- assertEquals("new cumulative delsI", 1, newCumulativeDelsI -
cumulativeDelsI);
+ assertEquals(
+ "Did not have the expected number of submitted deletes_by_id",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"deletes_by_id").getValue(),
+ 0.0);
+
+ assertEquals(
+ "No deletes_by_id should have been committed yet",
+ 0,
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops",
"deletes_by_id").getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of cumulative deletes_by_id",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_id").getValue(),
+ 0.0);
// not committed yet
assertQ(req("q", "id:5"), "//*[@numFound='1']");
assertU(commit());
- // delsI should be reset to 0 after commit
- newDelsI = ((Gauge<Number>) metrics.get(delsIName)).getValue().longValue();
- newCumulativeDelsI = ((Meter) metrics.get(cumulativeDelsIName)).getCount();
- assertEquals("new delsI after commit", 0, newDelsI);
- assertEquals("new cumulative delsI after commit", 1, newCumulativeDelsI -
cumulativeDelsI);
+
+ assertEquals(
+ "Did not have the expected number of submitted deletes_by_id",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"deletes_by_id").getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of committed deletes_by_id",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops",
"deletes_by_id").getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of cumulative deletes_by_id after
commit",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_id").getValue(),
+ 0.0);
// 5 should be gone
assertQ(req("q", "id:5"), "//*[@numFound='0']");
@@ -182,35 +211,76 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
// now delete all
assertU(delQ("*:*"));
- long newDelsQ = ((Gauge<Number>)
metrics.get(delsQName)).getValue().longValue();
- long newCumulativeDelsQ = ((Meter)
metrics.get(cumulativeDelsQName)).getCount();
- assertEquals("new delsQ", 1, newDelsQ);
- assertEquals("new cumulative delsQ", 1, newCumulativeDelsQ -
cumulativeDelsQ);
+ assertEquals(
+ "Did not have the expected number of submitted deletes_by_query",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"deletes_by_query")
+ .getValue(),
+ 0.0);
+
+ assertEquals(
+ "No deletes_by_query should have been committed yet",
+ 0,
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops",
"deletes_by_query")
+ .getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of pending cumulative deletes_by_id",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_query").getValue(),
+ 0.0);
// not committed yet
assertQ(req("q", "id:6"), "//*[@numFound='1']");
assertU(commit());
- newDelsQ = ((Gauge<Number>) metrics.get(delsQName)).getValue().longValue();
- newCumulativeDelsQ = ((Meter) metrics.get(cumulativeDelsQName)).getCount();
- assertEquals("new delsQ after commit", 0, newDelsQ);
- assertEquals("new cumulative delsQ after commit", 1, newCumulativeDelsQ -
cumulativeDelsQ);
+ assertEquals(
+ "Did not have the expected number of submitted deletes_by_query",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_submitted_ops",
"deletes_by_query")
+ .getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of committed deletes_by_query",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_committed_ops",
"deletes_by_query")
+ .getValue(),
+ 0.0);
+
+ assertEquals(
+ "Did not have the expected number of pending cumulative
deletes_by_query after commit",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_query").getValue(),
+ 0.0);
// 6 should be gone
assertQ(req("q", "id:6"), "//*[@numFound='0']");
// verify final metrics
- newCommits = ((Meter) metrics.get(commitsName)).getCount();
- assertEquals("new commits", 3, newCommits - commits);
- newAdds = ((Gauge<Number>) metrics.get(addsName)).getValue().longValue();
- assertEquals("new adds", 0, newAdds);
- newCumulativeAdds = ((Meter) metrics.get(cumulativeAddsName)).getCount();
- assertEquals("new cumulative adds", 2, newCumulativeAdds - cumulativeAdds);
- newDelsI = ((Gauge<Number>) metrics.get(delsIName)).getValue().longValue();
- assertEquals("new delsI", 0, newDelsI);
- newCumulativeDelsI = ((Meter) metrics.get(cumulativeDelsIName)).getCount();
- assertEquals("new cumulative delsI", 1, newCumulativeDelsI -
cumulativeDelsI);
+ var commits = getCounterOpDatapoint(core, "solr_core_update_commit_ops",
"commits");
+ var cumulativeAdds = getGaugeOpDatapoint(core,
"solr_core_update_cumulative_ops", "adds");
+ var cumulativeDeletesById =
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_id");
+ var cumulativeDeletesByQuery =
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_query");
+
+ assertEquals(
+ "Did not have the expected number of cumulative commits", 3,
commits.getValue(), 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative adds", 2,
cumulativeAdds.getValue(), 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative delete_by_id",
+ 1,
+ cumulativeDeletesById.getValue(),
+ 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative deletes_by_query",
+ 1,
+ cumulativeDeletesByQuery.getValue(),
+ 0.0);
}
@Test
@@ -230,12 +300,29 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
CommitUpdateCommand cmtCmd = new CommitUpdateCommand(ureq, false);
cmtCmd.waitSearcher = true;
assertEquals(1, duh2.addCommands.longValue());
- assertEquals(1, duh2.addCommandsCumulative.getCount());
- assertEquals(0, duh2.commitCommands.getCount());
+
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertNull(
+ "No commits should have been processed yet",
+ getCounterOpDatapoint(core, "solr_core_update_commit_ops", "commits"));
+
updater.commit(cmtCmd);
assertEquals(0, duh2.addCommands.longValue());
- assertEquals(1, duh2.addCommandsCumulative.getCount());
- assertEquals(1, duh2.commitCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative commits",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_commit_ops",
"commits").getValue(),
+ 0.0);
+
ureq.close();
assertU(adoc("id", "B"));
@@ -244,12 +331,28 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
ureq = req();
RollbackUpdateCommand rbkCmd = new RollbackUpdateCommand(ureq);
assertEquals(1, duh2.addCommands.longValue());
- assertEquals(2, duh2.addCommandsCumulative.getCount());
- assertEquals(0, duh2.rollbackCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 2,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertNull(
+ "No rollbacks should have been processed yet",
+ getGaugeOpDatapoint(core, "solr_core_update_maintenance_ops",
"rollback"));
+
updater.rollback(rbkCmd);
assertEquals(0, duh2.addCommands.longValue());
- assertEquals(1, duh2.addCommandsCumulative.getCount());
- assertEquals(1, duh2.rollbackCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative rollback",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_maintenance_ops",
"rollback").getValue(),
+ 0.0);
+
ureq.close();
// search - "B" should not be found.
@@ -292,12 +395,28 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
CommitUpdateCommand cmtCmd = new CommitUpdateCommand(ureq, false);
cmtCmd.waitSearcher = true;
assertEquals(2, duh2.addCommands.longValue());
- assertEquals(2, duh2.addCommandsCumulative.getCount());
- assertEquals(0, duh2.commitCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 2,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertNull(
+ "No commits should have been processed yet",
+ getCounterOpDatapoint(core, "solr_core_update_cumulative_ops",
"commits"));
+
updater.commit(cmtCmd);
+
assertEquals(0, duh2.addCommands.longValue());
- assertEquals(2, duh2.addCommandsCumulative.getCount());
- assertEquals(1, duh2.commitCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 2,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"adds").getValue(),
+ 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative commits",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_commit_ops",
"commits").getValue(),
+ 0.0);
ureq.close();
// search - "A","B" should be found.
@@ -327,13 +446,29 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
ureq = req();
RollbackUpdateCommand rbkCmd = new RollbackUpdateCommand(ureq);
assertEquals(1, duh2.deleteByIdCommands.longValue());
- assertEquals(1, duh2.deleteByIdCommandsCumulative.getCount());
- assertEquals(0, duh2.rollbackCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 1,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_id").getValue(),
+ 0.0);
+ assertNull(
+ "No rollbacks should have been processed yet",
+ getGaugeOpDatapoint(core, "solr_core_update_maintenance_ops",
"rollback"));
+
updater.rollback(rbkCmd);
ureq.close();
+
assertEquals(0, duh2.deleteByIdCommands.longValue());
- assertEquals(0, duh2.deleteByIdCommandsCumulative.getCount());
- assertEquals(1, duh2.rollbackCommands.getCount());
+ assertEquals(
+ "Did not have the expected number of cumulative adds",
+ 0,
+ getGaugeOpDatapoint(core, "solr_core_update_cumulative_ops",
"deletes_by_id").getValue(),
+ 0.0);
+ assertEquals(
+ "Did not have the expected number of cumulative rollback",
+ 1,
+ getCounterOpDatapoint(core, "solr_core_update_maintenance_ops",
"rollback").getValue(),
+ 0.0);
// search - "B" should be found.
assertQ(
@@ -477,4 +612,26 @@ public class DirectUpdateHandlerTest extends
SolrTestCaseJ4 {
newSearcherOpenedAt.set(newSearcher.getOpenNanoTime());
}
}
+
+ private GaugeSnapshot.GaugeDataPointSnapshot getGaugeOpDatapoint(
+ SolrCore core, String metricName, String operation) {
+ return SolrMetricTestUtils.getGaugeDatapoint(
+ core,
+ metricName,
+ SolrMetricTestUtils.newStandaloneLabelsBuilder(core)
+ .label("category", "UPDATE")
+ .label("ops", operation)
+ .build());
+ }
+
+ private CounterSnapshot.CounterDataPointSnapshot getCounterOpDatapoint(
+ SolrCore core, String metricName, String operation) {
+ return SolrMetricTestUtils.getCounterDatapoint(
+ core,
+ metricName,
+ SolrMetricTestUtils.newStandaloneLabelsBuilder(core)
+ .label("category", "UPDATE")
+ .label("ops", operation)
+ .build());
+ }
}
diff --git a/solr/webapp/web/js/angular/controllers/plugins.js
b/solr/webapp/web/js/angular/controllers/plugins.js
index a537b37d7c3..5bf7ab5edaa 100644
--- a/solr/webapp/web/js/angular/controllers/plugins.js
+++ b/solr/webapp/web/js/angular/controllers/plugins.js
@@ -15,6 +15,8 @@
limitations under the License.
*/
+//NOCOMMIT: This plugin seems tied to the Admin UIs plugin management but is
tied to dropwizard metrics failing some tests.
+// This needs to change how it gets these metrics or we need to make a shim to
the /admin/plugins handler for this to support it
solrAdminApp.controller('PluginsController',
function($scope, $rootScope, $routeParams, $location, Mbeans, Constants) {
$scope.resetMenu("plugins", Constants.IS_CORE_PAGE);
