/// <summary> /// Initializes a new instance of the <see cref="PerformanceCollectorModule"/> class. /// </summary> public PerformanceCollectorModule() { this.Counters = new List <PerformanceCounterCollectionRequest>(); this.collector = this.collector ?? (PerformanceCounterUtility.IsWebAppRunningInAzure() ? (IPerformanceCollector) new WebAppPerformanceCollector() : (IPerformanceCollector) new StandardPerformanceCollector()); }
internal void PerformanceCollectorBadStateTest(IPerformanceCollector collector) { var counters = new PerformanceCounter[] { new PerformanceCounter("Processor", "% Processor Time", "_Total123blabla"), new PerformanceCounter("Processor", "% Processor Time", "_Total") }; foreach (var pc in counters) { try { string error = null; collector.RegisterCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), null, true, out error, false); } catch (Exception) { } } Assert.IsTrue(collector.PerformanceCounters.First().IsInBadState); Assert.IsFalse(collector.PerformanceCounters.Last().IsInBadState); }
private PerformanceCounter CreateCounter( string perfCounterName, IEnumerable <string> win32Instances, IEnumerable <string> clrInstances, out bool usesInstanceNamePlaceholder, out string error) { error = null; try { return(PerformanceCounterUtility.ParsePerformanceCounter( perfCounterName, win32Instances, clrInstances, out usesInstanceNamePlaceholder)); } catch (Exception e) { usesInstanceNamePlaceholder = false; PerformanceCollectorEventSource.Log.CounterParsingFailedEvent(e.Message, perfCounterName); error = e.Message; return(null); } }
private void RefreshCounter( PerformanceCounterData pcd, IEnumerable <string> win32Instances, IEnumerable <string> clrInstances) { string dummy; bool usesInstanceNamePlaceholder; var pc = this.CreateCounter( pcd.OriginalString, win32Instances, clrInstances, out usesInstanceNamePlaceholder, out dummy); try { this.collector.RefreshPerformanceCounter(pcd, pc); PerformanceCollectorEventSource.Log.CounterRegisteredEvent( PerformanceCounterUtility.FormatPerformanceCounter(pc)); } catch (InvalidOperationException e) { PerformanceCollectorEventSource.Log.CounterRegistrationFailedEvent( e.Message, PerformanceCounterUtility.FormatPerformanceCounter(pc)); } }
/// <summary> /// Performs collection for all registered counters. /// </summary> /// <param name="onReadingFailure">Invoked when an individual counter fails to be read.</param> public IEnumerable <Tuple <PerformanceCounterData, double> > Collect( Action <string, Exception> onReadingFailure = null) { return(this.performanceCounters.Where(pc => !pc.Item1.IsInBadState).SelectMany( pc => { double value; try { value = CollectCounter(pc.Item2); } catch (InvalidOperationException e) { if (onReadingFailure != null) { onReadingFailure( PerformanceCounterUtility.FormatPerformanceCounter(pc.Item2), e); } return new Tuple <PerformanceCounterData, double>[] { }; } return new[] { Tuple.Create(pc.Item1, value) }; })); }
public PerformanceCounterStructure CreateCounter( string perfCounterName, bool supportInstanceNames, out bool usesInstanceNamePlaceholder, out string error) { error = null; try { return(PerformanceCounterUtility.ParsePerformanceCounter( perfCounterName, new string[] { }, new string[] { }, supportInstanceNames, out usesInstanceNamePlaceholder)); } catch (Exception e) { usesInstanceNamePlaceholder = false; PerformanceCollectorEventSource.Log.CounterParsingFailedEvent(e.Message, perfCounterName); error = e.Message; return(null); } }
private void RegisterCounter( string originalString, string reportAs, PerformanceCounterStructure pc, bool isCustomCounter, bool usesInstanceNamePlaceholder, out string error) { error = null; try { this.RegisterPerformanceCounter( originalString, reportAs, pc.CategoryName, pc.CounterName, pc.InstanceName, usesInstanceNamePlaceholder, isCustomCounter); PerformanceCollectorEventSource.Log.CounterRegisteredEvent( PerformanceCounterUtility.FormatPerformanceCounter(pc)); } catch (InvalidOperationException e) { PerformanceCollectorEventSource.Log.CounterRegistrationFailedEvent( e.Message, PerformanceCounterUtility.FormatPerformanceCounter(pc)); error = e.Message; } }
internal void PerformanceCollectorAddRemoveCountersTest(StandardPerformanceCollector collector) { var counters = new[] { new PerformanceCounter("Processor", "% Processor Time", "_Total"), new PerformanceCounter("Memory", "Available Bytes", string.Empty) }; foreach (var pc in counters) { string error; collector.RegisterCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), pc.GetHashCode().ToString(CultureInfo.InvariantCulture), true, out error, false); } var twoCounters = collector.PerformanceCounters.ToArray(); collector.RemoveCounter(@"\PROCESSOR(_Total)\% Processor Time", counters[0].GetHashCode().ToString(CultureInfo.InvariantCulture)); var oneCounter = collector.PerformanceCounters.ToArray(); Assert.AreEqual(2, twoCounters.Count()); Assert.AreEqual(@"\Processor(_Total)\% Processor Time", twoCounters[0].OriginalString); Assert.AreEqual(@"\Memory\Available Bytes", twoCounters[1].OriginalString); Assert.AreEqual(@"\Memory\Available Bytes", oneCounter.Single().OriginalString); }
internal void PerformanceCollectorAddRemoveCountersForWebAppTest(WebAppPerformanceCollector collector) { var counters = new[] { new PerformanceCounter("ASP.NET Applications", "Request Execution Time", "??APP_W3SVC_PROC??"), new PerformanceCounter("ASP.NET Applications", "Requests In Application Queue", "??APP_W3SVC_PROC??") }; foreach (var pc in counters) { string error; collector.RegisterCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), pc.GetHashCode().ToString(CultureInfo.InvariantCulture), true, out error, false); } var twoCounters = collector.PerformanceCounters.ToArray(); collector.RemoveCounter( @"\ASP.NET APPLICATIONS(??APP_W3SVC_PROC??)\Request Execution Time", counters[0].GetHashCode().ToString(CultureInfo.InvariantCulture)); var oneCounter = collector.PerformanceCounters.ToArray(); Assert.AreEqual(2, twoCounters.Count()); Assert.AreEqual(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Request Execution Time", twoCounters[0].OriginalString); Assert.AreEqual(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests In Application Queue", twoCounters[1].OriginalString); Assert.AreEqual(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests In Application Queue", oneCounter.Single().OriginalString); }
/// <summary> /// Rebinds performance counters to Windows resources. /// </summary> public void RefreshPerformanceCounter(PerformanceCounterData pcd) { Tuple <PerformanceCounterData, ICounterValue> tupleToRemove = this.performanceCounters.FirstOrDefault(t => t.Item1 == pcd); if (tupleToRemove != null) { this.performanceCounters.Remove(tupleToRemove); } try { this.RegisterPerformanceCounter( pcd.OriginalString, pcd.ReportAs, pcd.PerformanceCounter.CategoryName, pcd.PerformanceCounter.CounterName, pcd.PerformanceCounter.InstanceName, pcd.UsesInstanceNamePlaceholder); } catch (InvalidOperationException e) { PerformanceCollectorEventSource.Log.CounterRegistrationFailedEvent( e.Message, PerformanceCounterUtility.FormatPerformanceCounter(pcd.PerformanceCounter)); } }
public void PerformanceCollectorBadStateTest() { var counters = new PerformanceCounter[] { new PerformanceCounter("Processor", "% Processor Time", "_Total123blabla"), new PerformanceCounter("Processor", "% Processor Time", "_Total") }; IPerformanceCollector collector = new PerformanceCollector(); foreach (var pc in counters) { try { collector.RegisterPerformanceCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), null, pc.CategoryName, pc.CounterName, pc.InstanceName, false, true); } catch (Exception) { } } Assert.IsTrue(collector.PerformanceCounters.First().IsInBadState); Assert.IsFalse(collector.PerformanceCounters.Last().IsInBadState); }
public void PerformanceCollectorRefreshTest() { var counters = new PerformanceCounter[] { new PerformanceCounter("Processor", "% Processor Time", "_Total"), new PerformanceCounter("Processor", "% Processor Time", "_Total") }; var newCounter = new PerformanceCounter("Memory", "Available Bytes", string.Empty); IPerformanceCollector collector = new PerformanceCollector(); foreach (var pc in counters) { collector.RegisterPerformanceCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), null, pc.CategoryName, pc.CounterName, pc.InstanceName, false, true); } collector.RefreshPerformanceCounter(collector.PerformanceCounters.Last(), newCounter); Assert.IsTrue(collector.PerformanceCounters.Last().PerformanceCounter.CategoryName == newCounter.CategoryName); Assert.IsTrue(collector.PerformanceCounters.Last().PerformanceCounter.CounterName == newCounter.CounterName); Assert.IsTrue(collector.PerformanceCounters.Last().PerformanceCounter.InstanceName == newCounter.InstanceName); }
internal void PerformanceCollectorRefreshCountersTest(IPerformanceCollector collector) { var counters = new PerformanceCounter[] { new PerformanceCounter("Processor", "% Processor Time", "_Total123blabla"), new PerformanceCounter("Processor", "% Processor Time", "_Total"), new PerformanceCounter("Processor", "% Processor Time", "_Total123afadfdsdf"), }; foreach (var pc in counters) { try { string error = null; collector.RegisterCounter( PerformanceCounterUtility.FormatPerformanceCounter(pc), null, true, out error, false); } catch (Exception) { } } collector.RefreshCounters(); // All bad state counters are removed and added later through register counter, and as a result, the order of the performance coutners is changed. Assert.AreEqual(collector.PerformanceCounters.First().PerformanceCounter.InstanceName, "_Total"); Assert.AreEqual(collector.PerformanceCounters.Last().PerformanceCounter.InstanceName, "_Total123afadfdsdf"); }
/// <summary> /// Registers a counter using the counter name and reportAs value to the total list of counters. /// </summary> /// <param name="perfCounter">Name of the performance counter.</param> /// <param name="reportAs">Report as name for the performance counter.</param> /// <param name="isCustomCounter">Boolean to check if the performance counter is custom defined.</param> /// <param name="error">Captures the error logged.</param> /// <param name="blockCounterWithInstancePlaceHolder">Boolean that controls the registry of the counter based on the availability of instance place holder.</param> public void RegisterCounter( string perfCounter, string reportAs, bool isCustomCounter, out string error, bool blockCounterWithInstancePlaceHolder) { try { bool useInstancePlaceHolder = false; var pc = PerformanceCounterUtility.CreateAndValidateCounter(perfCounter, null, null, out useInstancePlaceHolder, out error); if (pc != null) { this.RegisterPerformanceCounter(perfCounter, this.GetCounterReportAsName(perfCounter, reportAs), pc.CategoryName, pc.CounterName, pc.InstanceName, useInstancePlaceHolder, false); } else { // Even if validation failed, we might still be able to collect perf counter in WebApp. this.RegisterPerformanceCounter(perfCounter, this.GetCounterReportAsName(perfCounter, reportAs), string.Empty, perfCounter, string.Empty, useInstancePlaceHolder, false); } } catch (Exception e) { PerformanceCollectorEventSource.Log.WebAppCounterRegistrationFailedEvent( e.Message, perfCounter); error = e.Message; } }
/// <summary> /// Registers a counter using the counter name and reportAs value to the total list of counters. /// </summary> /// <param name="perfCounterName">Name of the performance counter.</param> /// <param name="reportAs">Report as name for the performance counter.</param> /// <param name="isCustomCounter">Boolean to check if the performance counter is custom defined.</param> /// <param name="error">Captures the error logged.</param> /// <param name="blockCounterWithInstancePlaceHolder">Boolean that controls the registry of the counter based on the availability of instance place holder.</param> public void RegisterCounter( string perfCounterName, string reportAs, bool isCustomCounter, out string error, bool blockCounterWithInstancePlaceHolder = false) { bool usesInstanceNamePlaceholder; if (!this.dependendentInstancesLoaded) { this.LoadDependentInstances(); this.dependendentInstancesLoaded = true; } var pc = PerformanceCounterUtility.CreateAndValidateCounter( perfCounterName, this.win32Instances, this.clrInstances, out usesInstanceNamePlaceholder, out error); // If blockCounterWithInstancePlaceHolder is true, then we register the counter only if usesInstanceNamePlaceHolder is true. if (pc != null && !(blockCounterWithInstancePlaceHolder && usesInstanceNamePlaceholder)) { this.RegisterCounter(perfCounterName, reportAs, pc, isCustomCounter, usesInstanceNamePlaceholder, out error); } }
private void InitializeServiceClient(TelemetryConfiguration configuration) { if (this.serviceClient != null) { // service client has been passed through a constructor, we don't need to do anything return; } Uri serviceEndpointUri; if (string.IsNullOrWhiteSpace(this.QuickPulseServiceEndpoint)) { // endpoint is not specified in configuration, use the default one serviceEndpointUri = QuickPulseDefaults.ServiceEndpoint; } else { // endpoint appears to have been specified in configuration, try using it try { serviceEndpointUri = new Uri(this.QuickPulseServiceEndpoint); } catch (Exception e) { throw new ArgumentException( string.Format( CultureInfo.InvariantCulture, "Error initializing QuickPulse module. QPS endpoint is not a correct URI: '{0}'", this.QuickPulseServiceEndpoint), e); } } // create the default production implementation of the service client with the best service endpoint we could get string instanceName = GetInstanceName(configuration); string streamId = GetStreamId(); string machineName = Environment.MachineName; var assemblyVersion = SdkVersionUtils.GetSdkVersion(null); bool isWebApp = PerformanceCounterUtility.IsWebAppRunningInAzure(); int? processorCount = PerformanceCounterUtility.GetProcessorCount(isWebApp); this.serviceClient = new QuickPulseServiceClient( serviceEndpointUri, instanceName, streamId, machineName, assemblyVersion, this.timeProvider, isWebApp, processorCount ?? 0); QuickPulseEventSource.Log.TroubleshootingMessageEvent( string.Format( CultureInfo.InvariantCulture, "Service client initialized. Endpoint: '{0}', instance name: '{1}', assembly version: '{2}'", serviceEndpointUri, instanceName, assemblyVersion)); }
/// <summary> /// Initialize method is called after all configuration properties have been loaded from the configuration. /// </summary> public void Initialize(TelemetryConfiguration configuration) { if (!this.isInitialized) { lock (this.lockObject) { if (!this.isInitialized) { PerformanceCollectorEventSource.Log.ModuleIsBeingInitializedEvent( string.Format( CultureInfo.InvariantCulture, "Custom counters count: '{0}'", Counters?.Count ?? 0)); if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (!this.defaultCountersInitialized) { this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Process(??APP_WIN32_PROC??)\% Processor Time", @"\Process(??APP_WIN32_PROC??)\% Processor Time")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Process(??APP_WIN32_PROC??)\% Processor Time Normalized", @"\Process(??APP_WIN32_PROC??)\% Processor Time Normalized")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Memory\Available Bytes", @"\Memory\Available Bytes")); #if !NETSTANDARD2_0 // Exclude those counters which don't exist for .netcore this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests/Sec", @"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests/Sec")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\.NET CLR Exceptions(??APP_CLR_PROC??)\# of Exceps Thrown / sec", @"\.NET CLR Exceptions(??APP_CLR_PROC??)\# of Exceps Thrown / sec")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Request Execution Time", @"\ASP.NET Applications(??APP_W3SVC_PROC??)\Request Execution Time")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests In Application Queue", @"\ASP.NET Applications(??APP_W3SVC_PROC??)\Requests In Application Queue")); #endif this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Process(??APP_WIN32_PROC??)\Private Bytes", @"\Process(??APP_WIN32_PROC??)\Private Bytes")); this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Process(??APP_WIN32_PROC??)\IO Data Bytes/sec", @"\Process(??APP_WIN32_PROC??)\IO Data Bytes/sec")); if (!PerformanceCounterUtility.IsWebAppRunningInAzure()) { this.DefaultCounters.Add(new PerformanceCounterCollectionRequest(@"\Processor(_Total)\% Processor Time", @"\Processor(_Total)\% Processor Time")); } } if (!this.EnableIISExpressPerformanceCounters && IsRunningUnderIisExpress()) { PerformanceCollectorEventSource.Log.RunningUnderIisExpress(); return; } this.telemetryConfiguration = configuration; this.client = new TelemetryClient(configuration); this.client.Context.GetInternalContext().SdkVersion = SdkVersionUtils.GetSdkVersion(PerformanceCounterUtility.SDKVersionPrefix()); this.lastRefreshTimestamp = DateTime.MinValue; this.timer = new Timer(this.TimerCallback); // schedule the first tick this.timer.ScheduleNextTick(this.collectionPeriod); this.isInitialized = true; } } } }
/// <summary> /// Initialize method is called after all configuration properties have been loaded from the configuration. /// </summary> /// <param name="configuration">TelemetryConfiguration passed to the module.</param> public void Initialize(TelemetryConfiguration configuration) { if (!this.IsInitialized) { lock (this.moduleInitializationLock) { if (!this.IsInitialized) { QuickPulseEventSource.Log.ModuleIsBeingInitializedEvent( this.QuickPulseServiceEndpoint, this.DisableFullTelemetryItems, this.DisableTopCpuProcesses, this.AuthenticationApiKey); QuickPulseEventSource.Log.TroubleshootingMessageEvent("Validating configuration..."); ValidateConfiguration(configuration); this.config = configuration; QuickPulseEventSource.Log.TroubleshootingMessageEvent("Initializing members..."); this.collectionTimeSlotManager = this.collectionTimeSlotManager ?? new QuickPulseCollectionTimeSlotManager(); this.performanceCollector = this.performanceCollector ?? PerformanceCounterUtility.GetPerformanceCollector(); this.timeProvider = this.timeProvider ?? new Clock(); this.topCpuCollector = this.topCpuCollector ?? new QuickPulseTopCpuCollector(this.timeProvider, new QuickPulseProcessProvider(PerfLib.GetPerfLib())); this.timings = this.timings ?? QuickPulseTimings.Default; CollectionConfigurationError[] errors; this.collectionConfiguration = new CollectionConfiguration( new CollectionConfigurationInfo() { ETag = string.Empty }, out errors, this.timeProvider); this.dataAccumulatorManager = this.dataAccumulatorManager ?? new QuickPulseDataAccumulatorManager(this.collectionConfiguration); this.InitializeServiceClient(configuration); this.stateManager = new QuickPulseCollectionStateManager( this.ServiceClient, this.timeProvider, this.timings, this.OnStartCollection, this.OnStopCollection, this.OnSubmitSamples, this.OnReturnFailedSamples, this.OnUpdatedConfiguration, this.OnUpdatedServiceEndpoint); this.CreateStateThread(); this.IsInitialized = true; } } } }
/// <summary> /// Binds processes to performance counters instance names and adds performance counters to the collection. /// </summary> /// <remarks>This operation is expensive, but must be done periodically to account for IIS changing instance names /// of the counters it reports Web Sites on as worker processes start and terminate.</remarks> private void EnsurePerformanceCountersRegistered() { if (DateTime.Now - this.lastRefreshTimestamp < this.registrationPeriod) { // re-registration period hasn't elapsed yet, do nothing return; } PerformanceCounterUtility.InvalidatePlaceholderCache(); if (this.lastRefreshTimestamp == DateTime.MinValue) { // this is the initial registration, register everything this.ProcessCustomCounters(); string error; var errors = new List <string>(); foreach (PerformanceCounterCollectionRequest req in this.DefaultCounters.Union(this.Counters)) { this.collector.RegisterCounter( req.PerformanceCounter, req.ReportAs, true, out error, false); if (!string.IsNullOrWhiteSpace(error)) { errors.Add( string.Format( CultureInfo.InvariantCulture, "Counter {0}: {1}", req.PerformanceCounter, error)); } } if (errors.Any()) { // send out the unified error message PerformanceCollectorEventSource.Log.CounterCheckConfigurationEvent( errors.Count.ToString(CultureInfo.InvariantCulture), string.Join(Environment.NewLine, errors)); } } else { // this is a periodic refresh this.collector.RefreshCounters(); } // as per MSDN, we need to wait at least 1s before proceeding with counter collection Thread.Sleep(TimeSpan.FromSeconds(1)); this.lastRefreshTimestamp = DateTime.Now; }
/// <summary> /// Initializes a new instance of the <see cref="XPlatProcessCPUPerformanceCounterNormalized" /> class. /// </summary> internal XPlatProcessCPUPerformanceCounterNormalized() : base() { int?count = PerformanceCounterUtility.GetProcessorCount(); if (count.HasValue) { this.processorsCount = count.Value; this.isInitialized = true; } }
/// <summary> /// Initializes a new instance of the <see cref="NormalizedCPUPercentageGauge"/> class. /// </summary> /// <param name="name"> Name of the SumUpCountersGauge.</param> /// <param name="value"> Gauges to sum.</param> public NormalizedCPUPercentageGauge(string name, ICounterValue value) : base(name, value) { int?count = PerformanceCounterUtility.GetProcessorCount(); if (count.HasValue) { this.processorsCount = count.Value; this.isInitialized = true; } }
public void PerformanceCounterUtilitySanityTest() { var win32Instances = PerformanceCounterUtility.GetWin32ProcessInstances(); var clrInstances = PerformanceCounterUtility.GetClrProcessInstances(); var win32Instance = PerformanceCounterUtility.GetInstanceForWin32Process(win32Instances); var clrInstance = PerformanceCounterUtility.GetInstanceForClrProcess(clrInstances); PerformanceCounterUtility.GetInstanceForCurrentW3SvcWorker(); }
private void WriteSamples(IEnumerable <QuickPulseDataSample> samples, string instrumentationKey, Stream stream, CollectionConfigurationError[] errors) { var monitoringPoints = new List <MonitoringDataPoint>(); foreach (var sample in samples) { var metricPoints = new List <MetricPoint>(); metricPoints.AddRange(CreateDefaultMetrics(sample)); metricPoints.AddRange( sample.PerfCountersLookup.Select(counter => new MetricPoint { Name = counter.Key, Value = Round(counter.Value), Weight = 1, })); metricPoints.AddRange(CreateCalculatedMetrics(sample)); ITelemetryDocument[] documents = sample.TelemetryDocuments.ToArray(); Array.Reverse(documents); ProcessCpuData[] topCpuProcesses = sample.TopCpuData.Select(p => new ProcessCpuData() { ProcessName = p.Item1, CpuPercentage = p.Item2, }).ToArray(); var dataPoint = new MonitoringDataPoint { Version = this.version, InvariantVersion = MonitoringDataPoint.CurrentInvariantVersion, InstrumentationKey = instrumentationKey, Instance = this.instanceName, RoleName = this.roleName, StreamId = this.streamId, MachineName = this.machineName, Timestamp = sample.EndTimestamp.UtcDateTime, IsWebApp = this.isWebApp, PerformanceCollectionSupported = PerformanceCounterUtility.IsPerfCounterSupported(), ProcessorCount = this.processorCount, Metrics = metricPoints.ToArray(), Documents = documents, GlobalDocumentQuotaReached = sample.GlobalDocumentQuotaReached, TopCpuProcesses = topCpuProcesses.Length > 0 ? topCpuProcesses : null, TopCpuDataAccessDenied = sample.TopCpuDataAccessDenied, CollectionConfigurationErrors = errors, }; monitoringPoints.Add(dataPoint); } this.serializerDataPointArray.WriteObject(stream, monitoringPoints.ToArray()); }
/// <summary> /// Initializes a new instance of the <see cref="NormalizedProcessCPUPerformanceCounter" /> class. /// </summary> /// <param name="categoryName">The counter category name.</param> /// <param name="counterName">The counter name.</param> /// <param name="instanceName">The instance name.</param> internal NormalizedProcessCPUPerformanceCounter(string categoryName, string counterName, string instanceName) { int?count = PerformanceCounterUtility.GetProcessorCount(false); if (count.HasValue) { this.processorsCount = count.Value; this.performanceCounter = new PerformanceCounter("Process", "% Processor Time", instanceName, true); this.isInitialized = true; } }
public void ParsePerformanceCounterTest() { PerformanceCounter pc; pc = PerformanceCounterUtility.ParsePerformanceCounter(@"\Processor(_Total)\% Processor Time", null, null); Assert.AreEqual("Processor", pc.CategoryName); Assert.AreEqual("% Processor Time", pc.CounterName); Assert.AreEqual("_Total", pc.InstanceName); pc = PerformanceCounterUtility.ParsePerformanceCounter(@"\Memory\Available Memory", null, null); Assert.AreEqual("Memory", pc.CategoryName); Assert.AreEqual("Available Memory", pc.CounterName); Assert.AreEqual(string.Empty, pc.InstanceName); }
public void GetCollectorReturnsWebAppCollector() { try { Environment.SetEnvironmentVariable("WEBSITE_SITE_NAME", "something"); var actual = PerformanceCounterUtility.GetPerformanceCollector(); Assert.AreEqual("WebAppPerformanceCollector", actual.GetType().Name); } finally { PerformanceCounterUtility.isAzureWebApp = null; Environment.SetEnvironmentVariable("WEBSITE_SITE_NAME", string.Empty); Task.Delay(1000).Wait(); } }
public void ParsePerformanceCounterTest() { PerformanceCounterStructure pc; bool usesInstanceNamePlaceholder; pc = PerformanceCounterUtility.ParsePerformanceCounter(@"\Processor(_Total)\% Processor Time", null, null, true, out usesInstanceNamePlaceholder); Assert.AreEqual("Processor", pc.CategoryName); Assert.AreEqual("% Processor Time", pc.CounterName); Assert.AreEqual("_Total", pc.InstanceName); pc = PerformanceCounterUtility.ParsePerformanceCounter(@"\Memory\Available Memory", null, null, true, out usesInstanceNamePlaceholder); Assert.AreEqual("Memory", pc.CategoryName); Assert.AreEqual("Available Memory", pc.CounterName); Assert.AreEqual(string.Empty, pc.InstanceName); }
public void GetCollectorReturnsCorrectCollector() { try { var actual = PerformanceCounterUtility.GetPerformanceCollector(); #if NETCOREAPP2_0 Assert.AreEqual("StandardPerformanceCollector", actual.GetType().Name); #else // NET452 Assert.AreEqual("StandardPerformanceCollector", actual.GetType().Name); #endif } finally { PerformanceCounterUtility.isAzureWebApp = null; } }
/// <summary> /// Returns the current value of the counter as a <c ref="MetricTelemetry"/>. /// </summary> /// <returns>Value of the counter.</returns> public double Collect() { try { return(this.performanceCounter.NextValue()); } catch (Exception e) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, Resources.PerformanceCounterReadFailed, PerformanceCounterUtility.FormatPerformanceCounter(this.performanceCounter)), e); } }
public void GetCollectorReturnsXPlatformCollectorForNonWindows() { #if NETCOREAPP2_0 var original = PerformanceCounterUtility.IsWindows; try { PerformanceCounterUtility.IsWindows = false; var actual = PerformanceCounterUtility.GetPerformanceCollector(); Assert.AreEqual("PerformanceCollectorXPlatform", actual.GetType().Name); } finally { PerformanceCounterUtility.IsWindows = original; PerformanceCounterUtility.isAzureWebApp = null; } #endif }