internal PerformanceCounterData(string name, string description, PerformanceCounterType counterType, PerformanceCounterActionMapping[] mappings) { this.Name = name; this.Description = description; this.CounterType = counterType; this.Mappings = mappings; }
public CounterCreationData(String counterName, String counterHelp, PerformanceCounterType counterType) { this.counterName = counterName; this.counterHelp = counterHelp; this.counterType = counterType; }
public PerformanceCounter(String categoryName, String counterName, String instanceName, String machineName) { if (categoryName == null) { throw new ArgumentNullException("categoryName"); } if (counterName == null) { throw new ArgumentNullException("counterName"); } if (instanceName == null) { throw new ArgumentNullException("instanceName"); } if (machineName == null) { throw new ArgumentNullException("machineName"); } this.categoryName = categoryName; this.counterName = counterName; this.instanceName = instanceName; this.machineName = machineName; this.counterType = (PerformanceCounterType) Enum.Parse(typeof(PerformanceCounterType), counterName); }
public CounterDesc(string name, string desc, PerformanceCounterType type, Action <BasePerfMonAppender, CounterDesc> setter) { this.Name = name; this.Desc = desc; this.type = type; this.setter = setter; }
private static void Create(string categoryName, string counterHelp, PerformanceCounterType counterType) { var cd = new CounterCreationDataCollection { new CounterCreationData("Value", counterHelp, counterType) }; switch (counterType) { case PerformanceCounterType.AverageCount64: case PerformanceCounterType.AverageTimer32: cd.Add(new CounterCreationData("ValueBase", counterHelp, PerformanceCounterType.AverageBase)); break; case PerformanceCounterType.CounterMultiTimer: case PerformanceCounterType.CounterMultiTimerInverse: case PerformanceCounterType.CounterMultiTimer100Ns: case PerformanceCounterType.CounterMultiTimer100NsInverse: cd.Add(new CounterCreationData("ValueBase", counterHelp, PerformanceCounterType.CounterMultiBase)); break; case PerformanceCounterType.RawFraction: cd.Add(new CounterCreationData("ValueBase", counterHelp, PerformanceCounterType.RawBase)); break; case PerformanceCounterType.SampleFraction: cd.Add(new CounterCreationData("ValueBase", counterHelp, PerformanceCounterType.SampleBase)); break; } PerformanceCounterCategory.Create(categoryName, counterHelp, PerformanceCounterCategoryType.SingleInstance, cd); }
public PerfCounterCreationData(PerformanceCounterName name, PerformanceCounterType type, string displayName, string helpText) { counterName = name; counterType = type; counterDisplayName = displayName; counterHelpText = helpText; }
internal PerformanceCounterDefinition(string categoryName, string counterName, string counterHelp, PerformanceCounterType counterType) { _categoryName = categoryName; _counterName = counterName; _counterHelp = counterHelp; _counterType = counterType; }
internal PerformanceCounterDefinition(string categoryName, string counterName, string counterHelp, PerformanceCounterType counterType) { _categoryName = categoryName; _counterName = counterName; _counterHelp = counterHelp; _counterType = counterType; }
internal static void RegisterCounters(string installationPath) { string filename = Path.Combine(installationPath, "Microsoft.Exchange.Diagnostics.Service.Common.EdsPerformanceCounters.xml"); SafeXmlDocument safeXmlDocument = new SafeXmlDocument(); safeXmlDocument.Load(filename); string text = LoadEdsPerformanceCounters.ReadStringElement(safeXmlDocument, "Category/Name"); Logger.LogInformationMessage("Found performance counter category {0}", new object[] { text }); if (!LoadEdsPerformanceCounters.SafeExists(text)) { Logger.LogInformationMessage("Registering EDS performance counters.", new object[0]); CounterCreationDataCollection counterCreationDataCollection = new CounterCreationDataCollection(); XmlNodeList xmlNodeList = safeXmlDocument.SelectNodes("Category/Counters/Counter"); using (xmlNodeList) { for (int i = 0; i < xmlNodeList.Count; i++) { string text2 = LoadEdsPerformanceCounters.ReadStringElement(xmlNodeList[i], "Name"); PerformanceCounterType counterType = (PerformanceCounterType)Enum.Parse(typeof(PerformanceCounterType), LoadEdsPerformanceCounters.ReadStringElement(xmlNodeList[i], "Type"), true); counterCreationDataCollection.Add(new CounterCreationData(text2, string.Empty, counterType)); Logger.LogInformationMessage("Loaded counter {0}", new object[] { text2 }); } } LoadEdsPerformanceCounters.SafeCreate(text, counterCreationDataCollection); return; } Logger.LogInformationMessage("Counters are already registered.", new object[0]); }
/// <summary> /// Add a custom performance counter. Counter won't be installed until InstallCounters() is called. /// </summary> public static void TrackCustomCounter(string name, string helpText, PerformanceCounterType type, TimeSpan sampleInterval, int maxSamplesToCache, string divisor) { if (m_Sampling) { return; } CounterCreationData ccd = new CounterCreationData(); ccd.CounterName = name; ccd.CounterHelp = helpText; ccd.CounterType = type; PerfHistory h = GetHistory(name, "Wisp", ""); try { h.Divisor = float.Parse(divisor); } catch (FormatException exc) { Log1.Logger("Performance").Error("Custom Counter " + h.Key + " has an invalid [Divisor] - must be in float format!"); h.Divisor = 1; } h.SampleInterval = sampleInterval; h.HelpText = helpText; h.MaxHistorySamplesToKeep = maxSamplesToCache; h.IsCustom = true; _Counters.Add(ccd); Log1.Logger("Performance").Debug("Tracking custom performance counter [" + name + "|Wisp|" + "]"); }
public Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress <Tuple <PerformanceCounterType, PerfCounterModel> > progress) { throw new NotImplementedException(); }
private void Add() { this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Adding Performance Counter Category: {0}", this.CategoryName)); CounterCreationDataCollection colCounterCreationData = new CounterCreationDataCollection(); colCounterCreationData.Clear(); if (PerformanceCounterCategory.Exists(this.CategoryName)) { this.LogTaskMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, "Removing Performance Counter Category: {0}", this.CategoryName)); PerformanceCounterCategory.Delete(this.CategoryName); } foreach (ITaskItem counter in this.CounterList) { string counterName = counter.GetMetadata("CounterName"); string counterHelp = counter.GetMetadata("CounterHelp"); PerformanceCounterType counterType = (PerformanceCounterType)Enum.Parse(typeof(PerformanceCounterType), counter.GetMetadata("CounterType")); this.LogTaskMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, "Adding Performance Counter: {0}", counterName)); CounterCreationData objCreateCounter = new CounterCreationData(counterName, counterHelp, counterType); colCounterCreationData.Add(objCreateCounter); } if (colCounterCreationData.Count > 0) { PerformanceCounterCategoryType categoryType = PerformanceCounterCategoryType.SingleInstance; if (this.MultiInstance) { categoryType = PerformanceCounterCategoryType.MultiInstance; } this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Creating Performance Counter Category: {0}", this.CategoryName)); PerformanceCounterCategory.Create(this.CategoryName, this.CategoryHelp, categoryType, colCounterCreationData); } }
/// <summary> /// Returns if a PerformanceCounterType is a base type for another counter type /// (AverageBase, CounterMultiBase, RawBase y SampleBase are Base Types) /// </summary> /// <param name="counterType">PerformanceCounterType</param> /// <returns>returns true if the type is a based counter type, otherwise false</returns> private static bool IsBaseType(PerformanceCounterType counterType) { return((counterType == PerformanceCounterType.AverageBase) || (counterType == PerformanceCounterType.CounterMultiBase) || (counterType == PerformanceCounterType.RawBase) || (counterType == PerformanceCounterType.SampleBase)); }
internal PerformanceCounterSample(string path, string instanceName, double cookedValue, UInt64 rawValue, UInt64 secondValue, uint multiCount, PerformanceCounterType counterType, UInt32 defaultScale, UInt64 timeBase, DateTime timeStamp, UInt64 timeStamp100nSec, UInt32 status) { _path = path; _instanceName = instanceName; _cookedValue = cookedValue; _rawValue = rawValue; _secondValue = secondValue; _multiCount = multiCount; _counterType = counterType; _defaultScale = defaultScale; _timeBase = timeBase; _timeStamp = timeStamp; _timeStamp100nSec = timeStamp100nSec; _status = status; }
internal PerformanceCounterSample(string path, string instanceName, double cookedValue, UInt64 rawValue, UInt64 secondValue, uint multiCount, PerformanceCounterType counterType, UInt32 defaultScale, UInt64 timeBase, DateTime timeStamp, UInt64 timeStamp100nSec, UInt32 status) { _path = path; _instanceName = instanceName; _cookedValue = cookedValue; _rawValue = rawValue; _secondValue = secondValue; _multiCount = multiCount; _counterType = counterType; _defaultScale = defaultScale; _timeBase = timeBase; _timeStamp = timeStamp; _timeStamp100nSec = timeStamp100nSec; _status = status; }
public IICPerformanceCounter CreateCounter(string counterName, PerformanceCounterType counterType) { IICPerformanceCounter counter = new IICPerformanceCounter(); counter._rawAttr = new IICPerformanceCounterAttribute(counterName, counterType); _counters.Add(counter); return counter; }
public CounterDescriptor(string name, string help, PerformanceCounterType type) : this() { Name = name; Help = help; Type = type; }
/// <summary> /// Ensures the with category. /// </summary> /// <param name="category">The category.</param> /// <param name="counterName">Name of the counter.</param> /// <param name="type">The type.</param> /// <param name="deep">if set to <see langword="true"/> [deep].</param> /// <returns></returns> private PerformanceCounter EnsureWithCategory(string category, string counterName, PerformanceCounterType type, bool deep) { cacheLock.EnterUpgradeableReadLock(); try { if (categoryDict.ContainsKey(category)) { IDictionary <string, PerformanceCounter> perf = categoryDict[category]; return(EnsureCounter(category, counterName, type, perf)); } else { if (deep) { return(null); } return(EnsureCounter(category, counterName, type, null)); } } finally { cacheLock.ExitUpgradeableReadLock(); } }
internal PerformanceCounterData(string name, string description, PerformanceCounterType counterType, PerformanceCounterActionMapping[] mappings) { this.Name = name; this.Description = description; this.CounterType = counterType; this.Mappings = mappings; }
private CounterCreationData CreateCounter( string counterName, PerformanceCounterType counterType) { return(new CounterCreationData( counterName, counterName, counterType)); }
public static PerformanceCounterType BaseCounterType( this PerformanceCounterType counterType) { switch (counterType) { case PerformanceCounterType.AverageTimer32: case PerformanceCounterType.AverageCount64: return(PerformanceCounterType.AverageBase); case PerformanceCounterType.CounterMultiTimer: case PerformanceCounterType.CounterMultiTimer100Ns: case PerformanceCounterType.CounterMultiTimerInverse: case PerformanceCounterType.CounterMultiTimer100NsInverse: return(PerformanceCounterType.CounterMultiBase); case PerformanceCounterType.RawFraction: return(PerformanceCounterType.RawBase); case PerformanceCounterType.SampleFraction: case PerformanceCounterType.SampleCounter: return(PerformanceCounterType.SampleBase); default: throw new ArgumentException(""); } }
internal PerformanceCounterSample(string path, string instanceName, double cookedValue, UInt64 rawValue, UInt64 secondValue, uint multiCount, PerformanceCounterType counterType, UInt32 defaultScale, UInt64 timeBase, DateTime timeStamp, UInt64 timeStamp100nSec, UInt32 status) { Path = path; InstanceName = instanceName; CookedValue = cookedValue; RawValue = rawValue; SecondValue = secondValue; MultipleCount = multiCount; CounterType = counterType; DefaultScale = defaultScale; TimeBase = timeBase; Timestamp = timeStamp; Timestamp100NSec = timeStamp100nSec; Status = status; }
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress <Tuple <PerformanceCounterType, PerfCounterModel> > progress) { await Task.Run(async() => { var random = new Random(); int prevPoint = 0; while (true) { await Task.Yield(); int point = prevPoint > 0 ? prevPoint : startPoint; // Update the point price by a random factor of the range percent int number = (point + (int)(random.NextDouble() * random.Next(0, 30))) - random.Next(0, 50); if (number < minPoint) { number = random.Next(0, 10); } else if (number > maxPoint) { number = 100; } progress.Report(new Tuple <PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = number })); await Task.Delay(250); prevPoint = number; } }).ConfigureAwait(false); }
public CounterCreationDataInfo(string counterName, string instanceName, PerformanceCounterType counterType, string counterHelp) { this.counterName = counterName; this.instanceName = instanceName; this.counterHelp = counterHelp; this.counterType = counterType; }
void IPacket.ReadFields(PacketDefinition definition, SerializedPacket packet) { switch (definition.Version) { case 1: long baseValue; long counterTimeStamp; long counterFrequency; long systemFrequency; long timeStamp; long timeStamp100nSec; packet.GetField("baseValue", out baseValue); packet.GetField("counterTimeStamp", out counterTimeStamp); packet.GetField("counterFrequency", out counterFrequency); packet.GetField("systemFrequency", out systemFrequency); packet.GetField("timeStamp", out timeStamp); packet.GetField("timeStamp100nSec", out timeStamp100nSec); //conceptually we shouldn't persist this - it's always the same and it's always on our metric, however //we need it here for deserialization purposes because our metric packet object isn't available during //the deserialization process. int rawCounterType; packet.GetField("counterType", out rawCounterType); PerformanceCounterType counterType = (PerformanceCounterType)rawCounterType; //Now, create our sample object from this data m_Sample = new CounterSample((long)base.RawValue, baseValue, counterFrequency, systemFrequency, timeStamp, timeStamp100nSec, counterType, counterTimeStamp); break; default: throw new GibraltarPacketVersionException(definition.Version); } }
public static PerformanceCounter CreateSimpleCounter(string counterName, string counterHelp, PerformanceCounterType counterType, string categoryName, string categoryHelp) { CounterCreationDataCollection counterCollection = new CounterCreationDataCollection(); CounterCreationData counter = new CounterCreationData(counterName, counterHelp, counterType); counterCollection.Add(counter); if (PerformanceCounterCategory.Exists(categoryName)) { PerformanceCounterCategory.Delete(categoryName); } PerformanceCounterCategory appCategory = PerformanceCounterCategory.Create(categoryName, categoryHelp, PerformanceCounterCategoryType.SingleInstance, counterCollection); PerformanceCounter appCounter = new PerformanceCounter(categoryName, counterName, false); appCounter.RawValue = 0; return(appCounter); }
private BasicPerformanceCounter CreatePerformanceCounter(PerformanceCounterType type) { BasicPerformanceCounter counter = null; switch (type) { case PerformanceCounterType.CPU_Time: case PerformanceCounterType.RAM_Used: case PerformanceCounterType.DISK_Read: case PerformanceCounterType.DISK_Write: case PerformanceCounterType.Custom: counter = new BasicPerformanceCounter(type, _enabled); break; case PerformanceCounterType.NET_Received: case PerformanceCounterType.NET_Sent: counter = new NetworkPerformanceCounter(type, _enabled); break; } Debug.Assert(counter != null); _counters.Add(counter); return(counter); }
public CounterCreationDataInfo(string counterName, string instanceName, PerformanceCounterType counterType, string counterHelp) { this.counterName = counterName; this.instanceName = instanceName; this.counterHelp = counterHelp; this.counterType = counterType; }
public static PerformanceCounter CreateCounter(string name, string description, PerformanceCounterType type) { if (_countersAllowed == false) { return null; } string categoryName = Application.ProductName + "." + name; if (PerformanceCounterCategory.Exists(categoryName) == false) { CounterCreationDataCollection counters = new CounterCreationDataCollection(); CounterCreationData counterData = new CounterCreationData(); counterData.CounterName = name; counterData.CounterHelp = description; counterData.CounterType = type; counters.Add(counterData); PerformanceCounterCategory category = PerformanceCounterCategory.Create(categoryName, "Category for the counters of " + Application.ProductName, PerformanceCounterCategoryType.SingleInstance, counters); } PerformanceCounter counter = new PerformanceCounter(categoryName, name, string.Empty, false); return counter; }
public CounterCreationData(String counterName, String counterHelp, PerformanceCounterType counterType) { this.counterName = counterName; this.counterHelp = counterHelp; this.counterType = counterType; }
/// <summary> /// Gets the counter. /// </summary> /// <param name="category">The category.</param> /// <param name="counterName">Name of the counter.</param> /// <param name="type">The type.</param> /// <returns></returns> private PerformanceCounter GetCounter(string category, string counterName, PerformanceCounterType type) { if (string.IsNullOrEmpty(category) || string.IsNullOrEmpty(counterName)) { return(null); } try { PerformanceCounter pc = this.EnsureWithCategory(category, counterName, type, false); if (pc == null) { return(null); } pc.InstanceName = AppDomain.CurrentDomain.FriendlyName; return(pc); } catch (Exception ex) { Trace.WriteLine("Get counter failed! " + ex, "EnterpriseLoggingService.GetCounter"); } return(null); }
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress) { await Task.Run(async () => { var random = new Random(); int prevPoint = 0; while (true) { await Task.Yield(); int point = prevPoint > 0 ? prevPoint : startPoint; // Update the point price by a random factor of the range percent int number = (point + (int)(random.NextDouble() * random.Next(0, 30))) - random.Next(0, 50); if (number < minPoint) { number = random.Next(0, 10); } else if (number > maxPoint) { number = 100; } progress.Report(new Tuple<PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = number })); await Task.Delay(250); prevPoint = number; } }).ConfigureAwait(false); }
public IPerformanceCounterNumeric AttachNumericCounter(string counterName, PerformanceCounterType counterType = PerformanceCounterType.CountOfItems) { // Check numeric counter type. switch (counterType) { case PerformanceCounterType.CountOfItems: case PerformanceCounterType.CountPerSecond: case PerformanceCounterType.AverageValue: case PerformanceCounterType.DeltaValue: case PerformanceCounterType.PercentValue: case PerformanceCounterType.ElapsedTime: break; default: throw new ArgumentException(string.Format(Resources.Strings.InvalidNumericCounterType, counterType)); } var counter = new PerformanceCounterNumeric(counterName, counterType, Severity.None, this); // Add new performance counter into the child collection. using (new WriteLock(Lock)) { _child.Add(counter); _childCounters.Add(counter); } return(counter); }
/// <summary> /// Get the PerformanceCounterType of the base type associated to this counter /// </summary> /// <param name="type">PerformanceCounterType of the counter to be added</param> /// <returns>returns PerformanceCounterType for the base counter in case the PerformanceCounterType passed as parameter requires a base counter, otherwise null</returns> /// <seealso cref="PerformanceCounterType"/> internal static PerformanceCounterType?GetBaseType(PerformanceCounterType type) { PerformanceCounterType?rtnValue = null; switch (type) { case PerformanceCounterType.AverageCount64: case PerformanceCounterType.AverageTimer32: rtnValue = PerformanceCounterType.AverageBase; break; case PerformanceCounterType.RawFraction: rtnValue = PerformanceCounterType.RawBase; break; case PerformanceCounterType.CounterMultiTimer: case PerformanceCounterType.CounterMultiTimerInverse: case PerformanceCounterType.CounterMultiTimer100Ns: case PerformanceCounterType.CounterMultiTimer100NsInverse: rtnValue = PerformanceCounterType.CounterMultiBase; break; case PerformanceCounterType.SampleCounter: case PerformanceCounterType.SampleFraction: rtnValue = PerformanceCounterType.SampleBase; break; default: rtnValue = null; break; } return(rtnValue); }
public CounterDescriptor(string name, string help, PerformanceCounterType type) : this() { Name = name; Help = help; Type = type; }
public PerfCounterCreationData(PerformanceCounterName name, PerformanceCounterType type, string displayName, string helpText) { counterName = name; counterType = type; counterDisplayName = displayName; counterHelpText = helpText; }
protected PerformanceCounterDefinition AddDefinition(string counterName, string counterHelp, PerformanceCounterType counterType) { var definition = new PerformanceCounterDefinition(_categoryName, counterName, counterHelp, counterType); _counterDefinitions.Add(definition.GetCreationData()); return definition; }
public CounterCreationData (string counterName, string counterHelp, PerformanceCounterType counterType) { CounterName = counterName; CounterHelp = counterHelp; CounterType = counterType; }
public IICPerformanceCounter CreateCounter(string counterName, PerformanceCounterType counterType) { IICPerformanceCounter counter = new IICPerformanceCounter(); counter._rawAttr = new IICPerformanceCounterAttribute(counterName, counterType); _counters.Add(counter); return(counter); }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name of the counter</param> /// <param name="info">Information about the counter</param> /// <param name="counterType">Type of counter</param> /// <param name="baseAutoIncreased">if true, each time the performance counter increased/decreased its base will be increased/decrease on 1 point. Otherwise all that base management will need to be handed on client code</param> /// <seealso cref="PerformanceCounterType"/> public CounterAttribute(string name, string info, PerformanceCounterType counterType, bool baseAutoIncreased) : base() { this.name = name; this.info = info; this.counterType = counterType; this.baseAutoIncreased = baseAutoIncreased; }
public FluentCategoryConfigurator AddCounter( string name, string help = "", PerformanceCounterType type = PerformanceCounterType.NumberOfItems32) { _counters.Add(new CounterCreationData(name, help, type)); return this; }
public CounterCreationData(string counterName, string counterHelp, PerformanceCounterType counterType) { name = counterName; help = counterHelp; type = counterType; }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name of the counter</param> /// <param name="info">Information about the counter</param> /// <param name="counterType">Type of counter</param> /// <param name="baseAutoIncreased">if true, each time the performance counter increased/decreased its base will be increased/decrease on 1 point. Otherwise all that base management will need to be handed on client code</param> /// <seealso cref="PerformanceCounterType"/> public PerformanceCounterAttribute(string name, string info, PerformanceCounterType counterType, bool baseAutoIncreased) : base() { this._name = name; this._info = info; this._counterType = counterType; this._baseAutoIncreased = baseAutoIncreased; }
void CreateCounter(string name, PerformanceCounterType type, CounterCreationDataCollection collection) { var ccd = new CounterCreationData(); ccd.CounterName = name; ccd.CounterType = type; collection.Add(ccd); }
// Methods public STPPerformanceCounter( string counterName, string counterHelp, PerformanceCounterType pcType) { this._counterName = counterName; this._counterHelp = counterHelp; this._pcType = pcType; }
public static PerformanceCounterData CreatePerformanceCounterData(string category, string format, string name, string help, PerformanceCounterType type) { return new PerformanceCounterData() { Category = category, Name = string.Format(format, name), Help = help, Type = type, }; }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public CounterSample(long rawValue, long baseValue, long counterFrequency, long systemFrequency, long timeStamp, long timeStamp100nSec, PerformanceCounterType counterType, long counterTimeStamp) { this.rawValue = rawValue; this.baseValue = baseValue; this.timeStamp = timeStamp; this.counterFrequency = counterFrequency; this.counterType = counterType; this.timeStamp100nSec = timeStamp100nSec; this.systemFrequency = systemFrequency; this.counterTimeStamp = counterTimeStamp; }
protected PerformanceCounterAttribute( string categoryName, string counterName, PerformanceCounterType counterType, PerformanceCounterType? baseCounterType) { this.CategoryName = categoryName; this.CounterName = counterName; this.BaseCounterName = counterName + "Base"; this.CounterType = counterType; this.BaseCounterType = baseCounterType; this.CategoryType=PerformanceCounterCategoryType.MultiInstance; this.sharedDataRef = sharedData; }
public CounterSample(long rawValue, long baseValue, long counterFrequency, long systemFrequency, long timeStamp, long timeStamp100nSec, PerformanceCounterType counterType) : this(rawValue, baseValue, counterFrequency, systemFrequency, timeStamp, timeStamp100nSec, counterType, 0) { }
/// <summary> /// Converts a PerformanceCounterType to a string. /// </summary> /// <param name="Type">The type.</param> public static string PerformanceCounterTypeToString(PerformanceCounterType Type) { switch (Type) { case PerformanceCounterType.MemoryBytes: return "bytes"; case PerformanceCounterType.TimeMilliseconds: return "ms"; default: throw new InvalidOperationException("PerformanceCounterType has invalid value " + Type.ToString()); } }
private static float NormalizeValue(this float value, PerformanceCounterType counterType) { // TODO: figure out all scaling here. should be 0-100 range. switch (counterType) { case PerformanceCounterType.ElapsedTime: value *= 0.00001f; break; } return value; }
public CounterInfo(string host, string category, string name, string instance, PerformanceCounterType type, int samplingInterval, Predicate<double> condition = null, Func<double, double> transform = null) { Host = host; Category = category; Name = name; Instance = instance; Type = type; SamplingInterval = samplingInterval; Condition = condition; Transform = transform; }
public PmcCounter(string Name, string Help, PerformanceCounterType PmcType, Type HostCategory) { m_Name = string.Empty; m_Help = string.Empty; m_Type = PerformanceCounterType.NumberOfItems32; m_HostCategory = null; m_Bound = false; m_PerfCounter = null; m_Name = Name; m_Help = Help; m_Type = PmcType; m_HostCategory = HostCategory; }
public PerformanceCounterSample(string path, string instanceName, double cookedValue, ulong rawValue, ulong secondValue, uint multiCount, PerformanceCounterType counterType, uint defaultScale, ulong timeBase, DateTime timeStamp, ulong timeStamp100nSec, uint status) { this.Path = path; this.InstanceName = instanceName; this.CookedValue = cookedValue; this.RawValue = rawValue; this.SecondValue = secondValue; this.MultipleCount = multiCount; this.CounterType = counterType; this.DefaultScale = defaultScale; this.TimeBase = timeBase; this.Timestamp = timeStamp; this.Timestamp100NSec = timeStamp100nSec; this.Status = status; }
public void RegisterCounter(string counterName, string helpString, PerformanceCounterType performanceCounterType) { if (_items.ContainsKey(counterName)) throw new ArgumentException(Resources.CounterNameAlreadyExists); CounterCreationData counter = new CounterCreationData { CounterName = counterName, CounterHelp = helpString, CounterType = performanceCounterType }; _collection.Add(counter); _items.Add(counterName, counter); }
public async Task<int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType) { var random = new Random(); random.NextDouble(); var numbers = new List<int>(); for (int i = 0; i < 100; i++) { await Task.Yield(); int number = random.Next(0, 100); numbers.Insert(i, number); } return numbers.Sum() / numbers.Count; }
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress) { await Task.Run(async () => { while (true) { await Task.Yield(); var value = await GetPerformanceMeanValue(name, performanceCounterType, timeframeType); progress.Report( new Tuple<PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = value })); await Task.Delay(250); } }).ConfigureAwait(false); }
public void GetCounterSamples_ProcessorTime_HasReasonableValues(string counter, PerformanceCounterType counterType, double minValue, double maxValue, string instanceName, ulong timeBase) { var reader = new PerfmonCounterReader(); using (var cancellationTokenSource = new CancellationTokenSource()) { var sample = reader.GetCounterSamples(new[] { counter }, TimeSpan.FromSeconds(1), 1, cancellationTokenSource.Token) .SelectMany(set => set.CounterSamples) .First(); //TODO: this is bad form - replace with an object comparer Assert.Equal(counterType, sample.CounterType); Assert.InRange(sample.CookedValue, minValue, maxValue); Assert.Equal(instanceName, sample.InstanceName); Assert.Equal(timeBase, sample.TimeBase); Assert.True(sample.Path.ToLower().EndsWith(counter.ToLower())); } }
internal PerformanceCounterSample(string path, string instanceName, double cookedValue, ulong rawValue, ulong secondValue, long multiCount, PerformanceCounterType counterType, long defaultScale, ulong timeBase, DateTime timeStamp, ulong timeStamp100nSec, long status) { this._path = ""; this._instanceName = ""; this._timeStamp = DateTime.MinValue; this._path = path; this._instanceName = instanceName; this._cookedValue = cookedValue; this._rawValue = rawValue; this._secondValue = secondValue; this._multiCount = multiCount; this._counterType = counterType; this._defaultScale = defaultScale; this._timeBase = timeBase; this._timeStamp = timeStamp; this._timeStamp100nSec = timeStamp100nSec; this._status = status; }
/// <summary> /// Initializes a new instance of the <see cref="PerformanceCounterSettings" /> class. /// </summary> /// <param name="category">The name of the performance counter category for this performance counter.</param> /// <param name="counterType">The type of the performance counter.</param> /// <param name="name">The name of the performance counter.</param> public PerformanceCounterSettings(String category, PerformanceCounterType counterType, String name) { if (category == null) { throw new ArgumentNullException(nameof(category)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } Category = category; CounterType = counterType; Name = name; }