internal MetricsSinkAdapter(string name, string description, MetricsSink sink, string
context, MetricsFilter sourceFilter, MetricsFilter recordFilter, MetricsFilter
metricFilter, int period, int queueCapacity, int retryDelay, float retryBackoff,
int retryCount)
{
this.name = Preconditions.CheckNotNull(name, "name");
this.description = description;
this.sink = Preconditions.CheckNotNull(sink, "sink object");
this.context = context;
this.sourceFilter = sourceFilter;
this.recordFilter = recordFilter;
this.metricFilter = metricFilter;
this.period = Contracts.CheckArg(period, period > 0, "period");
firstRetryDelay = Contracts.CheckArg(retryDelay, retryDelay > 0, "retry delay");
this.retryBackoff = Contracts.CheckArg(retryBackoff, retryBackoff > 1, "retry backoff"
);
oobPutTimeout = (long)(firstRetryDelay * Math.Pow(retryBackoff, retryCount) * 1000
);
this.retryCount = retryCount;
this.queue = new SinkQueue <MetricsBuffer>(Contracts.CheckArg(queueCapacity, queueCapacity
> 0, "queue capacity"));
latency = registry.NewRate("Sink_" + name, "Sink end to end latency", false);
dropped = registry.NewCounter("Sink_" + name + "Dropped", "Dropped updates per sink"
, 0);
qsize = registry.NewGauge("Sink_" + name + "Qsize", "Queue size", 0);
sinkThread = new _Thread_86(this);
sinkThread.SetName(name);
sinkThread.SetDaemon(true);
}
/// <summary>
/// sets the txid and time for this locklist
/// </summary>
/// <param name="over">optional, the overrides</param>
private void SetTxIdAndTime(IOperationOverrides over)
{
if (over != null && over.TxId != ulong.MaxValue)
{
this.TxId = (long)over.TxId;
}
if (over != null && over.TxTime != ulong.MaxValue)
{
this.TxTime = (long)over.TxTime;
}
else
{
this.TxTime = MutableStat.ConvertTime(DateTime.UtcNow);
}
}
/// <summary>
/// performs the actions on apply, and maybe run the scheduled action
/// </summary>
/// <param name="txtime">the time the transaction has</param>
/// <param name="xid">the id for the transaction</param>
/// <param name="func">the function to run</param>
/// <param name="onMultiples">if true, this is only a run in multiples of</param>
private void DoActionsOnApply(long txtime, long xid, RunOnTxIdMultiplesFunction func, bool onMultiples = true)
{
// if we already saw this txid (multiple calls to DoActionsOnApply per txid are possible), exit now
if (xid == this.lastTxRun)
{
return;
}
// if we are still loading, exit now
if (this.ThisReplicaName == null)
{
return;
}
// first produce an instrumentation signal indicating we are applying this transaction
RingMasterServerInstrumentation.Instance.OnApply(txtime, xid);
// if we don't have a function, exit now
if (func == null)
{
return;
}
// we only run the periodic action if we have a proper configuration, and it is time to run it based on such config
if (onMultiples && (this.runOnTxIdMultiplesOf == 0 || (xid % this.runOnTxIdMultiplesOf) != 0))
{
return;
}
// if the time is too off, exit
if (Math.Abs((DateTime.UtcNow - MutableStat.ConvertTime(txtime)).TotalSeconds) > 60)
{
Trace.TraceInformation("skipping action because it likely comes from the past");
return;
}
// set the last txid seen
this.lastTxRun = xid;
// do the action
func(txtime, xid);
}
/// <summary>
/// runs the command from the path
/// </summary>
/// <param name="req">the request containing the command</param>
/// <param name="session">the session this command was run from</param>
/// <param name="lockList">the lock list of the invocation</param>
/// <returns>the repsonse to the command</returns>
internal virtual RequestResponse RunCommand(RequestCreate req, ClientSession session, ILockListTransaction lockList)
{
if (req == null)
{
throw new ArgumentNullException(nameof(req));
}
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
MutableStat stat = new MutableStat(new FirstStat(0, MutableStat.ConvertTime(DateTime.UtcNow), 0));
// we require the digest 'Commander'
if (!string.Equals(session.Auth.ClientDigest, CommanderDigest, StringComparison.InvariantCultureIgnoreCase))
{
return(new RequestResponse()
{
Content = "not executed",
ResponsePath = "command",
ResultCode = (int)Code.Authfailed,
Stat = stat,
});
}
string requestedCommand;
object content;
Code result = this.RunCommandPath(req.Path, req.Data, session, lockList, out requestedCommand, out content);
return(new RequestResponse()
{
Content = content,
ResponsePath = requestedCommand,
ResultCode = (int)result,
Stat = stat,
});
}
internal ContainerMetrics(MetricsSystem ms, ContainerId containerId, long flushPeriodMs
, long delayMs)
{
// Use a multiplier of 1000 to avoid losing too much precision when
// converting to integers
// This tracks overall CPU percentage of the machine in terms of percentage
// of 1 core similar to top
// Thus if you use 2 cores completely out of 4 available cores this value
// will be 200
// Metrics publishing status
// true if period elapsed
// true if container finished
// unregister
// lazily initialized
// Create a timer to unregister container metrics,
// whose associated thread run as a daemon.
this.recordInfo = Interns.Info(SourceName(containerId), RecordInfo.Description());
this.registry = new MetricsRegistry(recordInfo);
this.metricsSystem = ms;
this.containerId = containerId;
this.flushPeriodMs = flushPeriodMs;
this.unregisterDelayMs = delayMs < 0 ? 0 : delayMs;
ScheduleTimerTaskIfRequired();
this.pMemMBsStat = registry.NewStat(PmemUsageMetricName, "Physical memory stats",
"Usage", "MBs", true);
this.cpuCoreUsagePercent = registry.NewStat(PhyCpuUsageMetricName, "Physical Cpu core percent usage stats"
, "Usage", "Percents", true);
this.milliVcoresUsed = registry.NewStat(VcoreUsageMetricName, "1000 times Vcore usage"
, "Usage", "MilliVcores", true);
this.pMemLimitMbs = registry.NewGauge(PmemLimitMetricName, "Physical memory limit in MBs"
, 0);
this.vMemLimitMbs = registry.NewGauge(VmemLimitMetricName, "Virtual memory limit in MBs"
, 0);
this.cpuVcoreLimit = registry.NewGauge(VcoreLimitMetricName, "CPU limit in number of vcores"
, 0);
}
/// <summary>
/// Deserializes this instance from the given <see cref="BinaryReader"/>.
/// </summary>
/// <param name="binaryReader">The <see cref="BinaryReader"/> to deserialize from</param>
public void ReadFrom(BinaryReader binaryReader)
{
if (binaryReader == null)
{
throw new ArgumentNullException(nameof(binaryReader));
}
this.Id = binaryReader.ReadUInt64();
this.Name = binaryReader.ReadString();
int aclCount = binaryReader.ReadInt32();
if (aclCount > 0)
{
List <Acl> list = new List <Acl>(aclCount);
for (int i = 0; i < aclCount; i++)
{
string identifier = binaryReader.ReadString();
string scheme = binaryReader.ReadString();
int perm = binaryReader.ReadInt32();
Acl acl = new Acl(perm, new Id(scheme, identifier));
list.Add(acl);
}
this.Acl = list.AsReadOnly();
}
else
{
this.Acl = null;
}
IMutableStat loadedStat = new MutableStat();
loadedStat.Mzxid = binaryReader.ReadInt64();
loadedStat.Czxid = binaryReader.ReadInt64();
loadedStat.Pzxid = binaryReader.ReadInt64();
loadedStat.Aversion = binaryReader.ReadInt32();
loadedStat.Version = binaryReader.ReadInt32();
loadedStat.Cversion = binaryReader.ReadInt32();
loadedStat.Mtime = binaryReader.ReadInt64();
loadedStat.Ctime = binaryReader.ReadInt64();
loadedStat.DataLength = binaryReader.ReadInt32();
if (loadedStat.DataLength == -1)
{
loadedStat.DataLength = 0;
this.Data = null;
}
else
{
this.Data = binaryReader.ReadBytes(loadedStat.DataLength);
}
// NumEphemeralChildren is 0 after deserialization.
loadedStat.NumChildren = binaryReader.ReadInt32();
this.ParentId = binaryReader.ReadUInt64();
this.Stat = loadedStat;
////Trace.TraceInformation($"PersistedData.Read: Id={this.Id} ParentId={this.ParentId} Name={this.Name} #Children={loadedStat.NumChildren} M={this.Stat.Mzxid}");
}
