/// <exception cref="System.Exception"/> public virtual void TestJournal() { MetricsRecordBuilder metrics = MetricsAsserts.GetMetrics(journal.GetMetricsForTests ().GetName()); MetricsAsserts.AssertCounter("BatchesWritten", 0L, metrics); MetricsAsserts.AssertCounter("BatchesWrittenWhileLagging", 0L, metrics); MetricsAsserts.AssertGauge("CurrentLagTxns", 0L, metrics); IPCLoggerChannel ch = new IPCLoggerChannel(conf, FakeNsinfo, journalId, jn.GetBoundIpcAddress ()); ch.NewEpoch(1).Get(); ch.SetEpoch(1); ch.StartLogSegment(1, NameNodeLayoutVersion.CurrentLayoutVersion).Get(); ch.SendEdits(1L, 1, 1, Sharpen.Runtime.GetBytesForString("hello", Charsets.Utf8)) .Get(); metrics = MetricsAsserts.GetMetrics(journal.GetMetricsForTests().GetName()); MetricsAsserts.AssertCounter("BatchesWritten", 1L, metrics); MetricsAsserts.AssertCounter("BatchesWrittenWhileLagging", 0L, metrics); MetricsAsserts.AssertGauge("CurrentLagTxns", 0L, metrics); ch.SetCommittedTxId(100L); ch.SendEdits(1L, 2, 1, Sharpen.Runtime.GetBytesForString("goodbye", Charsets.Utf8 )).Get(); metrics = MetricsAsserts.GetMetrics(journal.GetMetricsForTests().GetName()); MetricsAsserts.AssertCounter("BatchesWritten", 2L, metrics); MetricsAsserts.AssertCounter("BatchesWrittenWhileLagging", 1L, metrics); MetricsAsserts.AssertGauge("CurrentLagTxns", 98L, metrics); }
public override void Snapshot(MetricsRecordBuilder builder, bool all) { lock (this) { if (all || Changed()) { numSamples += intervalStat.NumSamples(); builder.AddCounter(numInfo, numSamples).AddGauge(avgInfo, LastStat().Mean()); if (extended) { builder.AddGauge(stdevInfo, LastStat().Stddev()).AddGauge(iMinInfo, LastStat().Min ()).AddGauge(iMaxInfo, LastStat().Max()).AddGauge(minInfo, minMax.Min()).AddGauge (maxInfo, minMax.Max()); } if (Changed()) { if (numSamples > 0) { intervalStat.CopyTo(prevStat); intervalStat.Reset(); } ClearChanged(); } } } }
public virtual void TestMissingBlock() { // Create a file with single block with two replicas Path file = GetTestPath("testMissingBlocks"); CreateFile(file, 100, (short)1); // Corrupt the only replica of the block to result in a missing block LocatedBlock block = NameNodeAdapter.GetBlockLocations(cluster.GetNameNode(), file .ToString(), 0, 1).Get(0); cluster.GetNamesystem().WriteLock(); try { bm.FindAndMarkBlockAsCorrupt(block.GetBlock(), block.GetLocations()[0], "STORAGE_ID" , "TEST"); } finally { cluster.GetNamesystem().WriteUnlock(); } UpdateMetrics(); MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(NsMetrics); MetricsAsserts.AssertGauge("UnderReplicatedBlocks", 1L, rb); MetricsAsserts.AssertGauge("MissingBlocks", 1L, rb); MetricsAsserts.AssertGauge("MissingReplOneBlocks", 1L, rb); fs.Delete(file, true); WaitForDnMetricValue(NsMetrics, "UnderReplicatedBlocks", 0L); }
public override void Snapshot(MetricsRecordBuilder rb, bool all) { try { object ret = this._enclosing.method.Invoke(this._enclosing.obj, (object[])null); if (Org.Apache.Hadoop.Metrics2.Lib.MethodMetric.IsInt(t)) { rb.AddGauge(this._enclosing.info, ((int)ret)); } else { if (Org.Apache.Hadoop.Metrics2.Lib.MethodMetric.IsLong(t)) { rb.AddGauge(this._enclosing.info, ((long)ret)); } else { if (Org.Apache.Hadoop.Metrics2.Lib.MethodMetric.IsFloat(t)) { rb.AddGauge(this._enclosing.info, ((float)ret)); } else { rb.AddGauge(this._enclosing.info, ((double)ret)); } } } } catch (Exception ex) { Org.Apache.Hadoop.Metrics2.Lib.MethodMetric.Log.Error("Error invoking method " + this._enclosing.method.Name, ex); } }
public virtual void TestFields() { TestMetricsAnnotations.MyMetrics metrics = new TestMetricsAnnotations.MyMetrics(); MetricsSource source = MetricsAnnotations.MakeSource(metrics); metrics.c1.Incr(); metrics.c2.Incr(); metrics.g1.Incr(); metrics.g2.Incr(); metrics.g3.Incr(); metrics.r1.Add(1); metrics.s1.Add(1); metrics.rs1.Add("rs1", 1); MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(source); Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("C1", "C1"), 1); Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("Counter2", "Counter2 desc" ), 1L); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("G1", "G1"), 1); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("G2", "G2"), 1); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("G3", "g3 desc"), 1L); Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("R1NumOps", "Number of ops for r1" ), 1L); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("R1AvgTime", "Average time for r1" ), 1.0); Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("S1NumOps", "Number of ops for s1" ), 1L); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("S1AvgTime", "Average time for s1" ), 1.0); Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("Rs1NumOps", "Number of ops for rs1" ), 1L); Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("Rs1AvgTime", "Average time for rs1" ), 1.0); }
private void GetGcUsage(MetricsRecordBuilder rb) { long count = 0; long timeMillis = 0; foreach (GarbageCollectorMXBean gcBean in gcBeans) { long c = gcBean.GetCollectionCount(); long t = gcBean.GetCollectionTime(); MetricsInfo[] gcInfo = GetGcInfo(gcBean.GetName()); rb.AddCounter(gcInfo[0], c).AddCounter(gcInfo[1], t); count += c; timeMillis += t; } rb.AddCounter(JvmMetricsInfo.GcCount, count).AddCounter(JvmMetricsInfo.GcTimeMillis , timeMillis); if (pauseMonitor != null) { rb.AddCounter(JvmMetricsInfo.GcNumWarnThresholdExceeded, pauseMonitor.GetNumGcWarnThreadholdExceeded ()); rb.AddCounter(JvmMetricsInfo.GcNumInfoThresholdExceeded, pauseMonitor.GetNumGcInfoThresholdExceeded ()); rb.AddCounter(JvmMetricsInfo.GcTotalExtraSleepTime, pauseMonitor.GetTotalGcExtraSleepTime ()); } }
/// <exception cref="System.Exception"/> public virtual void TestUncacheQuiesces() { // Create a file Path fileName = new Path("/testUncacheQuiesces"); int fileLen = 4096; DFSTestUtil.CreateFile(fs, fileName, fileLen, (short)1, unchecked ((int)(0xFDFD))); // Cache it DistributedFileSystem dfs = cluster.GetFileSystem(); dfs.AddCachePool(new CachePoolInfo("pool")); dfs.AddCacheDirective(new CacheDirectiveInfo.Builder().SetPool("pool").SetPath(fileName ).SetReplication((short)3).Build()); GenericTestUtils.WaitFor(new _Supplier_484(), 1000, 30000); // Uncache it dfs.RemoveCacheDirective(1); GenericTestUtils.WaitFor(new _Supplier_495(), 1000, 30000); // Make sure that no additional messages were sent Sharpen.Thread.Sleep(10000); MetricsRecordBuilder dnMetrics = MetricsAsserts.GetMetrics(dn.GetMetrics().Name() ); MetricsAsserts.AssertCounter("BlocksCached", 1l, dnMetrics); MetricsAsserts.AssertCounter("BlocksUncached", 1l, dnMetrics); }
public virtual void TestDataNodeMetrics() { Configuration conf = new HdfsConfiguration(); SimulatedFSDataset.SetFactory(conf); MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).Build(); try { FileSystem fs = cluster.GetFileSystem(); long LongFileLen = int.MaxValue + 1L; DFSTestUtil.CreateFile(fs, new Path("/tmp.txt"), LongFileLen, (short)1, 1L); IList <DataNode> datanodes = cluster.GetDataNodes(); NUnit.Framework.Assert.AreEqual(datanodes.Count, 1); DataNode datanode = datanodes[0]; MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(datanode.GetMetrics().Name()); MetricsAsserts.AssertCounter("BytesWritten", LongFileLen, rb); NUnit.Framework.Assert.IsTrue("Expected non-zero number of incremental block reports" , MetricsAsserts.GetLongCounter("IncrementalBlockReportsNumOps", rb) > 0); } finally { if (cluster != null) { cluster.Shutdown(); } } }
/*job*/ /*map*/ /*reduce*/ private void CheckMetrics(int jobsSubmitted, int jobsCompleted, int jobsFailed, int jobsKilled, int jobsPreparing, int jobsRunning, int mapsLaunched, int mapsCompleted , int mapsFailed, int mapsKilled, int mapsRunning, int mapsWaiting, int reducesLaunched , int reducesCompleted, int reducesFailed, int reducesKilled, int reducesRunning , int reducesWaiting) { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics("MRAppMetrics"); MetricsAsserts.AssertCounter("JobsSubmitted", jobsSubmitted, rb); MetricsAsserts.AssertCounter("JobsCompleted", jobsCompleted, rb); MetricsAsserts.AssertCounter("JobsFailed", jobsFailed, rb); MetricsAsserts.AssertCounter("JobsKilled", jobsKilled, rb); MetricsAsserts.AssertGauge("JobsPreparing", jobsPreparing, rb); MetricsAsserts.AssertGauge("JobsRunning", jobsRunning, rb); MetricsAsserts.AssertCounter("MapsLaunched", mapsLaunched, rb); MetricsAsserts.AssertCounter("MapsCompleted", mapsCompleted, rb); MetricsAsserts.AssertCounter("MapsFailed", mapsFailed, rb); MetricsAsserts.AssertCounter("MapsKilled", mapsKilled, rb); MetricsAsserts.AssertGauge("MapsRunning", mapsRunning, rb); MetricsAsserts.AssertGauge("MapsWaiting", mapsWaiting, rb); MetricsAsserts.AssertCounter("ReducesLaunched", reducesLaunched, rb); MetricsAsserts.AssertCounter("ReducesCompleted", reducesCompleted, rb); MetricsAsserts.AssertCounter("ReducesFailed", reducesFailed, rb); MetricsAsserts.AssertCounter("ReducesKilled", reducesKilled, rb); MetricsAsserts.AssertGauge("ReducesRunning", reducesRunning, rb); MetricsAsserts.AssertGauge("ReducesWaiting", reducesWaiting, rb); }
public virtual void TestFinalState() { StartupProgressTestHelper.SetStartupProgressForFinalState(startupProgress); MetricsRecordBuilder builder = MetricsAsserts.GetMetrics(metrics, true); NUnit.Framework.Assert.IsTrue(MetricsAsserts.GetLongCounter("ElapsedTime", builder ) >= 0L); MetricsAsserts.AssertGauge("PercentComplete", 1.0f, builder); MetricsAsserts.AssertCounter("LoadingFsImageCount", 100L, builder); NUnit.Framework.Assert.IsTrue(MetricsAsserts.GetLongCounter("LoadingFsImageElapsedTime" , builder) >= 0L); MetricsAsserts.AssertCounter("LoadingFsImageTotal", 100L, builder); MetricsAsserts.AssertGauge("LoadingFsImagePercentComplete", 1.0f, builder); MetricsAsserts.AssertCounter("LoadingEditsCount", 200L, builder); NUnit.Framework.Assert.IsTrue(MetricsAsserts.GetLongCounter("LoadingEditsElapsedTime" , builder) >= 0L); MetricsAsserts.AssertCounter("LoadingEditsTotal", 200L, builder); MetricsAsserts.AssertGauge("LoadingEditsPercentComplete", 1.0f, builder); MetricsAsserts.AssertCounter("SavingCheckpointCount", 300L, builder); NUnit.Framework.Assert.IsTrue(MetricsAsserts.GetLongCounter("SavingCheckpointElapsedTime" , builder) >= 0L); MetricsAsserts.AssertCounter("SavingCheckpointTotal", 300L, builder); MetricsAsserts.AssertGauge("SavingCheckpointPercentComplete", 1.0f, builder); MetricsAsserts.AssertCounter("SafeModeCount", 400L, builder); NUnit.Framework.Assert.IsTrue(MetricsAsserts.GetLongCounter("SafeModeElapsedTime" , builder) >= 0L); MetricsAsserts.AssertCounter("SafeModeTotal", 400L, builder); MetricsAsserts.AssertGauge("SafeModePercentComplete", 1.0f, builder); }
/// <summary> /// Adds a gauge with a name built by using the specified phase's name as prefix /// and then appending the specified suffix. /// </summary> /// <param name="builder">MetricsRecordBuilder to receive counter</param> /// <param name="phase">Phase to add</param> /// <param name="nameSuffix">String suffix of metric name</param> /// <param name="descSuffix">String suffix of metric description</param> /// <param name="value">float gauge value</param> private static void AddGauge(MetricsRecordBuilder builder, Phase phase, string nameSuffix , string descSuffix, float value) { MetricsInfo metricsInfo = Interns.Info(phase.GetName() + nameSuffix, phase.GetDescription () + descSuffix); builder.AddGauge(metricsInfo, value); }
private void CheckMetrics(long hit, long cleared, long updated) { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics("RetryCache." + cacheName); MetricsAsserts.AssertCounter("CacheHit", hit, rb); MetricsAsserts.AssertCounter("CacheCleared", cleared, rb); MetricsAsserts.AssertCounter("CacheUpdated", updated, rb); }
//generate a new key per each call public virtual void GetMetrics(MetricsCollector collector, bool all) { MetricsRecordBuilder rb = collector.AddRecord("purgablesource").SetContext("test" ); this.lastKeyName = "key" + this.nextKey++; rb.AddGauge(Interns.Info(this.lastKeyName, "desc"), 1); }
public bool Get() { MetricsRecordBuilder dnMetrics = MetricsAsserts.GetMetrics(TestFsDatasetCache.dn. GetMetrics().Name()); long blocksUncached = MetricsAsserts.GetLongCounter("BlocksUncached", dnMetrics); return(blocksUncached > 0); }
/// <summary>Call getMetrics on source and get a record builder mock to verify</summary> /// <param name="source">the metrics source</param> /// <param name="all">if true, return all metrics even if not changed</param> /// <returns>the record builder mock to verify</returns> public static MetricsRecordBuilder GetMetrics(MetricsSource source, bool all) { MetricsRecordBuilder rb = MockMetricsRecordBuilder(); MetricsCollector mc = rb.Parent(); source.GetMetrics(mc, all); return(rb); }
public override void Snapshot(MetricsRecordBuilder builder, bool all) { if (all || Changed()) { builder.AddCounter(Info(), Value()); ClearChanged(); } }
public static long GetLongCounter(string name, MetricsRecordBuilder rb) { ArgumentCaptor <long> captor = ArgumentCaptor.ForClass <long>(); Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddCounter(EqName( Interns.Info(name, string.Empty)), captor.Capture()); CheckCaptured(captor, name); return(captor.GetValue()); }
public static float GetFloatGauge(string name, MetricsRecordBuilder rb) { ArgumentCaptor <float> captor = ArgumentCaptor.ForClass <float>(); Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddGauge(EqName(Interns.Info (name, string.Empty)), captor.Capture()); CheckCaptured(captor, name); return(captor.GetValue()); }
/// <exception cref="System.IO.IOException"/> private void DoRPCs(Configuration conf, bool expectFailure) { Server server = new RPC.Builder(conf).SetProtocol(typeof(TestRPC.TestProtocol)).SetInstance (new TestRPC.TestImpl()).SetBindAddress(Address).SetPort(0).SetNumHandlers(5).SetVerbose (true).Build(); server.RefreshServiceAcl(conf, new TestRPC.TestPolicyProvider()); TestRPC.TestProtocol proxy = null; server.Start(); IPEndPoint addr = NetUtils.GetConnectAddress(server); try { proxy = RPC.GetProxy <TestRPC.TestProtocol>(TestRPC.TestProtocol.versionID, addr, conf); proxy.Ping(); if (expectFailure) { NUnit.Framework.Assert.Fail("Expect RPC.getProxy to fail with AuthorizationException!" ); } } catch (RemoteException e) { if (expectFailure) { Assert.True(e.UnwrapRemoteException() is AuthorizationException ); } else { throw; } } finally { server.Stop(); if (proxy != null) { RPC.StopProxy(proxy); } MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(server.rpcMetrics.Name()); if (expectFailure) { MetricsAsserts.AssertCounter("RpcAuthorizationFailures", 1L, rb); } else { MetricsAsserts.AssertCounter("RpcAuthorizationSuccesses", 1L, rb); } //since we don't have authentication turned ON, we should see // 0 for the authentication successes and 0 for failure MetricsAsserts.AssertCounter("RpcAuthenticationFailures", 0L, rb); MetricsAsserts.AssertCounter("RpcAuthenticationSuccesses", 0L, rb); } }
public virtual void GetMetrics(MetricsCollector collector, bool all) { MetricsRecordBuilder rb = collector.AddRecord(JvmMetricsInfo.JvmMetrics).SetContext ("jvm").Tag(MsInfo.ProcessName, processName).Tag(MsInfo.SessionId, sessionId); GetMemoryUsage(rb); GetGcUsage(rb); GetThreadUsage(rb); GetEventCounters(rb); }
public static MetricsRecordBuilder MockMetricsRecordBuilder() { MetricsCollector mc = Org.Mockito.Mockito.Mock <MetricsCollector>(); MetricsRecordBuilder rb = Org.Mockito.Mockito.Mock <MetricsRecordBuilder>(new _Answer_66 (mc)); Org.Mockito.Mockito.When(mc.AddRecord(AnyString())).ThenReturn(rb); Org.Mockito.Mockito.When(mc.AddRecord(AnyInfo())).ThenReturn(rb); return(rb); }
public virtual void TestClasses() { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(MetricsAnnotations.MakeSource (new TestMetricsAnnotations.MyMetrics3())); MetricsCollector collector = rb.Parent(); Org.Mockito.Mockito.Verify(collector).AddRecord(Interns.Info("MyMetrics3", "My metrics" )); Org.Mockito.Mockito.Verify(rb).Add(Interns.Tag(MsInfo.Context, "foo")); }
/// <summary> /// Asserts that the NumOps and quantiles for a metric have been changed at /// some point to a non-zero value. /// </summary> /// <param name="prefix">of the metric</param> /// <param name="rb">MetricsRecordBuilder with the metric</param> public static void AssertQuantileGauges(string prefix, MetricsRecordBuilder rb) { Org.Mockito.Mockito.Verify(rb).AddGauge(EqName(Interns.Info(prefix + "NumOps", string.Empty )), AdditionalMatchers.Geq(0l)); foreach (Quantile q in MutableQuantiles.quantiles) { string nameTemplate = prefix + "%dthPercentileLatency"; int percentile = (int)(100 * q.quantile); Org.Mockito.Mockito.Verify(rb).AddGauge(EqName(Interns.Info(string.Format(nameTemplate , percentile), string.Empty)), AdditionalMatchers.Geq(0l)); } }
public virtual void TearDown() { MetricsSource source = DefaultMetricsSystem.Instance().GetSource("UgiMetrics"); if (source != null) { // Run only once since the UGI metrics is cleaned up during teardown MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(source); MetricsAsserts.AssertQuantileGauges("GetGroups1s", rb); } cluster.Shutdown(); }
public static void CheckApps(MetricsSource source, int submitted, int pending, int running, int completed, int failed, int killed, bool all) { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(source, all); MetricsAsserts.AssertCounter("AppsSubmitted", submitted, rb); MetricsAsserts.AssertGauge("AppsPending", pending, rb); MetricsAsserts.AssertGauge("AppsRunning", running, rb); MetricsAsserts.AssertCounter("AppsCompleted", completed, rb); MetricsAsserts.AssertCounter("AppsFailed", failed, rb); MetricsAsserts.AssertCounter("AppsKilled", killed, rb); }
/// <summary> /// Test that capacity metrics are exported and pass /// basic sanity tests. /// </summary> /// <exception cref="System.Exception"/> public virtual void TestCapacityMetrics() { MetricsRecordBuilder rb = MetricsAsserts.GetMetrics(NsMetrics); long capacityTotal = MetricsAsserts.GetLongGauge("CapacityTotal", rb); System.Diagnostics.Debug.Assert((capacityTotal != 0)); long capacityUsed = MetricsAsserts.GetLongGauge("CapacityUsed", rb); long capacityRemaining = MetricsAsserts.GetLongGauge("CapacityRemaining", rb); long capacityUsedNonDFS = MetricsAsserts.GetLongGauge("CapacityUsedNonDFS", rb); System.Diagnostics.Debug.Assert((capacityUsed + capacityRemaining + capacityUsedNonDFS == capacityTotal)); }
public virtual void TestMutableRates() { MetricsRecordBuilder rb = MetricsAsserts.MockMetricsRecordBuilder(); MetricsRegistry registry = new MetricsRegistry("test"); MutableRates rates = new MutableRates(registry); rates.Init(typeof(TestMutableMetrics.TestProtocol)); registry.Snapshot(rb, false); MetricsAsserts.AssertCounter("FooNumOps", 0L, rb); MetricsAsserts.AssertGauge("FooAvgTime", 0.0, rb); MetricsAsserts.AssertCounter("BarNumOps", 0L, rb); MetricsAsserts.AssertGauge("BarAvgTime", 0.0, rb); }
private void GetMemoryUsage(MetricsRecordBuilder rb) { MemoryUsage memNonHeap = memoryMXBean.GetNonHeapMemoryUsage(); MemoryUsage memHeap = memoryMXBean.GetHeapMemoryUsage(); Runtime runtime = Runtime.GetRuntime(); rb.AddGauge(JvmMetricsInfo.MemNonHeapUsedM, memNonHeap.GetUsed() / M).AddGauge(JvmMetricsInfo .MemNonHeapCommittedM, memNonHeap.GetCommitted() / M).AddGauge(JvmMetricsInfo.MemNonHeapMaxM , memNonHeap.GetMax() / M).AddGauge(JvmMetricsInfo.MemHeapUsedM, memHeap.GetUsed () / M).AddGauge(JvmMetricsInfo.MemHeapCommittedM, memHeap.GetCommitted() / M).AddGauge (JvmMetricsInfo.MemHeapMaxM, memHeap.GetMax() / M).AddGauge(JvmMetricsInfo.MemMaxM , runtime.MaxMemory() / M); }
public override void Snapshot(MetricsRecordBuilder rb, bool all) { try { object ret = this._enclosing.method.Invoke(this._enclosing.obj, (object[])null); rb.Tag(this._enclosing.info, (string)ret); } catch (Exception ex) { Org.Apache.Hadoop.Metrics2.Lib.MethodMetric.Log.Error("Error invoking method " + this._enclosing.method.Name, ex); } }
public virtual void GetMetrics(MetricsCollector builder, bool all) { lock (this) { MetricsRecordBuilder rb = builder.AddRecord(MsName).AddGauge(MsInfo.NumActiveSources , sources.Count).AddGauge(MsInfo.NumAllSources, allSources.Count).AddGauge(MsInfo .NumActiveSinks, sinks.Count).AddGauge(MsInfo.NumAllSinks, allSinks.Count); foreach (MetricsSinkAdapter sa in sinks.Values) { sa.Snapshot(rb, all); } registry.Snapshot(rb, all); } }