/// <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);
}
}
