private static CounterCreationDataCollection GetCounterCreationDataCollectionForApmContextUsage(MethodInfo[] apmContextUsages) { var counterCreationDataCollection = new CounterCreationDataCollection(); Trace.TraceInformation("Number of get context uses actions: {0}", apmContextUsages.Length); foreach (var apmContextUsage in apmContextUsages) { var methodIdentifier = ApmContext.GetMethodIdentifier(apmContextUsage); var eventName = ApmContext.GetEventName(apmContextUsage); Trace.TraceInformation("Setting up get context uses '{0}' for event '{1}'", methodIdentifier, eventName); //Setup action performance counters foreach (var counterHandler in PerformanceCounterApmHttpClientDelegatingHandler.CounterHandlers) { if (counterCreationDataCollection.Cast <CounterCreationData>().Any(x => x.CounterName == methodIdentifier)) { Trace.TraceInformation("Counter for method '{0}' was duplicate", methodIdentifier); } else { var countersToCreate = counterHandler.GetCreationData(methodIdentifier); foreach (var counterToCreate in countersToCreate) { Trace.TraceInformation("Added counter for method '{0}'", counterToCreate.CounterName); } counterCreationDataCollection.AddRange(countersToCreate); } } } return(counterCreationDataCollection); }
public static void Main() { try { // <Snippet1> // <Snippet2> string myCategoryName; int numberOfCounters; Console.Write("Enter the category Name :"); myCategoryName = Console.ReadLine(); // Check if the category already exists or not. if (!PerformanceCounterCategory.Exists(myCategoryName)) { Console.Write("Enter the number of counters : "); numberOfCounters = int.Parse(Console.ReadLine()); CounterCreationData[] myCounterCreationData = new CounterCreationData[numberOfCounters]; for (int i = 0; i < numberOfCounters; i++) { Console.Write("Enter the counter name for {0} counter : ", i); myCounterCreationData[i] = new CounterCreationData(); myCounterCreationData[i].CounterName = Console.ReadLine(); } CounterCreationDataCollection myCounterCollection = new CounterCreationDataCollection(); // Add the 'CounterCreationData[]' to 'CounterCollection'. myCounterCollection.AddRange(myCounterCreationData); PerformanceCounterCategory.Create(myCategoryName, "Sample Category", PerformanceCounterCategoryType.SingleInstance, myCounterCollection); if (myCounterCreationData.Length > 0) { if (myCounterCollection.Contains(myCounterCreationData[0])) { myCounterCollection.Remove(myCounterCreationData[0]); Console.WriteLine("'{0}' counter is removed from the " + "CounterCreationDataCollection", myCounterCreationData[0].CounterName); } } else { Console.WriteLine("The counters does not exist"); } } else { Console.WriteLine("The category already exists"); } // </Snippet2> // </Snippet1> } catch (Exception e) { Console.WriteLine("Exception: {0}.", e.Message); return; } }
public void ProfileActivated() { Logger.Debug("Starting installation of monitoring"); if (PerformanceCounterCategory.Exists(CategoryName)) { Logger.Warn(String.Format("Category {0} already exists, going to delete it first", CategoryName)); PerformanceCounterCategory.Delete(CategoryName); } CounterCreationDataCollection counterData = new CounterCreationDataCollection(); counterData.AddRange(this.InstallAverageMessageProcessTimeCounter()); counterData.AddRange(this.InstalledFailedMessageProcessingCounter()); PerformanceCounterCategory.Create(CategoryName, "NServiceBus Monitoring", PerformanceCounterCategoryType.MultiInstance, counterData); }
/// <summary> /// Installs performance counters in the assembly /// </summary> /// <param name="installerAssembly"></param> /// <param name="discoverer">object that can discover aspects inside and assembly</param> /// <param name="categoryName">category name for the metrics. If not provided, it will use the assembly name</param> public static void Install(Assembly installerAssembly, IInstrumentationDiscoverer discoverer, string categoryName = null) { Uninstall(installerAssembly, discoverer, categoryName); if (string.IsNullOrEmpty(categoryName)) { categoryName = installerAssembly.GetName().Name; } var instrumentationInfos = discoverer.Discover(installerAssembly).ToArray(); if (instrumentationInfos.Length == 0) { throw new InvalidOperationException("There are no instrumentationInfos found by the discoverer!"); } var counterCreationDataCollection = new CounterCreationDataCollection(); Trace.TraceInformation("Number of filters: {0}", instrumentationInfos.Length); foreach (var group in instrumentationInfos.GroupBy(x => x.CategoryName)) { foreach (var instrumentationInfo in group) { Trace.TraceInformation("Setting up filters '{0}'", instrumentationInfo.Description); foreach (var counterType in instrumentationInfo.Counters) { if (!HandlerFactories.ContainsKey(counterType)) { throw new ArgumentException("Counter type not defined: " + counterType); } // if already exists in the set then ignore if (counterCreationDataCollection.Cast <CounterCreationData>().Any(x => x.CounterName == counterType)) { Trace.TraceInformation("Counter type '{0}' was duplicate", counterType); continue; } using (var counterHandler = HandlerFactories[counterType](categoryName, instrumentationInfo.InstanceName)) { counterCreationDataCollection.AddRange(counterHandler.BuildCreationData().ToArray()); Trace.TraceInformation("Added counter type '{0}'", counterType); } } } var catName = string.IsNullOrEmpty(group.Key) ? categoryName : group.Key; PerformanceCounterCategory.Create(catName, "PerfIt category for " + catName, PerformanceCounterCategoryType.MultiInstance, counterCreationDataCollection); } Trace.TraceInformation("Built category '{0}' with {1} items", categoryName, counterCreationDataCollection.Count); }
/// <summary> /// Registers the performance counters with the operating system. /// </summary> private void CreatePerformanceCounters() { CounterCreationDataCollection ccdc = new CounterCreationDataCollection(); ccdc.AddRange(TaskManagerInstaller.COUNTERS); if (!PerformanceCounterCategory.Exists(TaskManagerInstaller.PERFORMANCE_COUNTER_CATEGORY)) { _performanceCounterCategory = PerformanceCounterCategory.Create(TaskManagerInstaller.PERFORMANCE_COUNTER_CATEGORY, TaskManagerInstaller.PERFORMANCE_COUNTER_DESCRIPTION, PerformanceCounterCategoryType.SingleInstance, ccdc); } }
/// <summary> /// Register Orleans perf counters with Windows /// </summary> /// <remarks>Note: Program needs to be running as Administrator to be able to delete Windows perf counters.</remarks> public static void InstallCounters() { var collection = new CounterCreationDataCollection(); collection.AddRange(GetCounterCreationData()); PerformanceCounterCategory.Create( CATEGORY_NAME, CATEGORY_DESCRIPTION, PerformanceCounterCategoryType.SingleInstance, collection); }
/// <summary> /// Creates a performance counter category for holding all the configured performance counters. /// </summary> /// <param name="counters"></param> private static void CreatePerformanceCounterCategory(CounterCreationData[] counters) { var counterData = new CounterCreationDataCollection(); counterData.AddRange(counters); if (PerformanceCounterCategory.Exists(CategoryName)) { PerformanceCounterCategory.Delete(CategoryName); } PerformanceCounterCategory.Create(CategoryName, "Performance counters defined for Logictracker.", PerformanceCounterCategoryType.SingleInstance, counterData); }
/// <summary> /// Add an average 32-bit timer performance counter to the list that will be created. /// </summary> /// <param name="name"> /// The name of the performance counter. This cannot be null, empty or whitespace. /// </param> /// <param name="help"> /// The description or help for the performance counter. This cannot be null, empty /// or whitespace. /// </param> /// <returns> /// A <seealso cref="PerformanceCounterCategory"/> used for creating additional /// performance counters. /// </returns> /// <exception cref="ArgumentNullException"> /// No argument can be null, empty or whitespace. /// </exception> /// <seealso cref="CreateCategory"/> public IPerformanceCounterCategoryFactory AddAverageTimer32(string name, string help) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } if (string.IsNullOrWhiteSpace(help)) { throw new ArgumentNullException(nameof(help)); } // Note: the base must immediately follow the non-base in the list. counterCreationDataCollection.AddRange(new [] { new CounterCreationData(name, help, PerformanceCounterType.AverageTimer32), new CounterCreationData(name + PerformanceCounterConstants.BaseSuffix, help, PerformanceCounterType.AverageBase) }); return(this); }
public static void Main() { try { string myCategoryName; int numberOfCounters; Console.Write("Enter the number of counters : "); numberOfCounters = int.Parse(Console.ReadLine()); CounterCreationData[] myCounterCreationData = new CounterCreationData[numberOfCounters]; for (int i = 0; i < numberOfCounters; i++) { Console.Write("Enter the counter name for {0} counter : ", i); myCounterCreationData[i] = new CounterCreationData(); myCounterCreationData[i].CounterName = Console.ReadLine(); } CounterCreationDataCollection myCounterCollection = new CounterCreationDataCollection(myCounterCreationData); Console.Write("Enter the category Name : "); myCategoryName = Console.ReadLine(); // Check if the category already exists or not. if (!PerformanceCounterCategory.Exists(myCategoryName)) { CounterCreationDataCollection myNewCounterCollection = new CounterCreationDataCollection(); // Add the 'CounterCreationDataCollection' to 'CounterCreationDataCollection' object. myNewCounterCollection.AddRange(myCounterCollection); PerformanceCounterCategory.Create(myCategoryName, "Sample Category", PerformanceCounterCategoryType.SingleInstance, myNewCounterCollection); Console.WriteLine("The list of counters in CounterCollection are: "); for (int i = 0; i < myNewCounterCollection.Count; i++) { Console.WriteLine("Counter {0} is '{1}'", i + 1, myNewCounterCollection[i].CounterName); } } else { Console.WriteLine("The category already exists"); } } catch (Exception e) { Console.WriteLine("Exception: {0}.", e.Message); return; } }
/// <summary> /// installs 4 standard counters for the category provided /// </summary> /// <param name="categoryName"></param> public static void InstallStandardCounters(string categoryName) { var creationDatas = new CounterHandlerBase[] { new AverageTimeHandler(categoryName, string.Empty), new LastOperationExecutionTimeHandler(categoryName, string.Empty), new TotalCountHandler(categoryName, string.Empty), new NumberOfOperationsPerSecondHandler(categoryName, string.Empty) }.SelectMany(x => x.BuildCreationData()); var counterCreationDataCollection = new CounterCreationDataCollection(); counterCreationDataCollection.AddRange(creationDatas.ToArray()); PerformanceCounterCategory.Create(categoryName, "PerfIt category for " + categoryName, PerformanceCounterCategoryType.MultiInstance, counterCreationDataCollection); }
/// <summary> /// Installs performance counters in the current assembly using PerfItFilterAttribute. /// </summary> /// /// <param name="categoryName">category name for the metrics. If not provided, it will use the assembly name</param> public static void Install(Assembly installerAssembly, string categoryName = null) { Uninstall(installerAssembly, categoryName); if (string.IsNullOrEmpty(categoryName)) { categoryName = installerAssembly.GetName().Name; } var perfItFilterAttributes = FindAllFilters(installerAssembly).ToArray(); var counterCreationDataCollection = new CounterCreationDataCollection(); Trace.TraceInformation("Number of filters: {0}", perfItFilterAttributes.Length); foreach (var filter in perfItFilterAttributes) { Trace.TraceInformation("Setting up filters '{0}'", filter.Description); foreach (var counterType in filter.Counters) { if (!HandlerFactories.ContainsKey(counterType)) { throw new ArgumentException("Counter type not defined: " + counterType); } // if already exists in the set then ignore if (counterCreationDataCollection.Cast <CounterCreationData>().Any(x => x.CounterName == counterType)) { Trace.TraceInformation("Counter type '{0}' was duplicate", counterType); continue; } using (var counterHandler = HandlerFactories[counterType](categoryName, filter.InstanceName)) { counterCreationDataCollection.AddRange(counterHandler.BuildCreationData()); Trace.TraceInformation("Added counter type '{0}'", counterType); } } } PerformanceCounterCategory.Create(categoryName, "PerfIt category for " + categoryName, PerformanceCounterCategoryType.MultiInstance, counterCreationDataCollection); Trace.TraceInformation("Built category '{0}' with {1} items", categoryName, counterCreationDataCollection.Count); }
public static void RegisterContract(Type contractType) { var categoryAttr = contractType.GetCustomAttribute <PerfCounterCategoryAttribute>(); if (null == categoryAttr) { throw new InvalidContractException($"Expected class with a {typeof(PerfCounterCategoryAttribute)} attribute"); } if (PerformanceCounterCategory.Exists(categoryAttr.Name)) { return; //throw new CategoryAlreadyExistsException($"Category {categoryAttr.Name} already exists"); } var counterCreationDataCollection = new CounterCreationDataCollection(); foreach (var prop in contractType.GetProperties()) { var attr = prop.GetCustomAttribute <PerfCounterAttribute>(); if (null == attr) { continue; } if (prop.GetGetMethod() == null) { throw new InvalidContractException($"Property {prop.Name} must have a getter and a setter to be valid."); } if (prop.PropertyType.BaseType.FullName != typeof(PerformanceCounterBase).FullName) { throw new InvalidContractException($"Property {prop.Name} must be of {typeof(PerformanceCounterBase).FullName} type."); } if (prop.PropertyType.CustomAttributes == null || !prop.PropertyType.CustomAttributes.Any(x => x.AttributeType.FullName == typeof(CounterTypeAttribute).FullName)) { throw new InvalidContractException($"Property {prop.Name} must have a {typeof(CounterTypeAttribute).FullName} attribute."); } var counterList = GetCounterCreationData(prop.PropertyType, attr); counterCreationDataCollection.AddRange(counterList.ToArray()); } PerformanceCounterCategory.Create(categoryAttr.Name, categoryAttr.Help, PerformanceCounterCategoryType.MultiInstance, counterCreationDataCollection); }
private static CounterCreationDataCollection GetCounterCreationDataCollectionForHttpActionDescriptors(ReflectedHttpActionDescriptor[] httpActionDescriptors) { var counterCreationDataCollection = new CounterCreationDataCollection(); Trace.TraceInformation("Number of controller actions: {0}", httpActionDescriptors.Length); foreach (var httpActionDescriptor in httpActionDescriptors) { var methodType = httpActionDescriptor.SupportedHttpMethods.First(); var controllerName = httpActionDescriptor.ControllerDescriptor.ControllerName; var actionName = httpActionDescriptor.ActionName; var param = httpActionDescriptor.MethodInfo.GetParameters() .Select(parameter => string.Format("{0} {1}", parameter.ParameterType.Name, parameter.Name)) .ToArray(); var arguments = string.Join(", ", param); var methodIdentifier = ApmWebApiFilterAttributeBase.GetMethodIdentifier(methodType, controllerName, actionName, arguments); var eventName = ApmWebApiFilterAttributeBase.GetEventName(methodType, actionName, controllerName); Trace.TraceInformation("Setting up controller action '{0}' for event '{1}'", methodIdentifier, eventName); //Setup action performance counters foreach (var counterHandler in PerformanceCounterApmApiFilterAttribute.CounterHandlers) { if (counterCreationDataCollection.Cast <CounterCreationData>().Any(x => x.CounterName == methodIdentifier)) { Trace.TraceInformation("Counter for method '{0}' was duplicate", methodIdentifier); } else { var countersToCreate = counterHandler.GetCreationData(methodIdentifier); foreach (var counterToCreate in countersToCreate) { Trace.TraceInformation("Added counter for method '{0}'", counterToCreate.CounterName); } counterCreationDataCollection.AddRange(countersToCreate); } } } return(counterCreationDataCollection); }
private static void SetupCounters(IEnumerable <ICounterExample> counterWorkers) { if (PerformanceCounterCategory.Exists(CounterCategory)) { Console.WriteLine("Deleting Performance Category {0}", CounterCategory); PerformanceCounterCategory.Delete(CounterCategory); } var counterCreationDatas = counterWorkers.SelectMany(counterWorker => counterWorker.GetCounterCreationData()).ToArray(); var counterDataCollection = new CounterCreationDataCollection(); counterDataCollection.AddRange(counterCreationDatas); Console.WriteLine("Creating Performance Category {0}", CounterCategory); PerformanceCounterCategory.Create( CounterCategory, "Demonstrates usage of various performance counter types.", PerformanceCounterCategoryType.SingleInstance, counterDataCollection); }
private static CounterCreationDataCollection GetCounterData(string category) { switch (category) { case KINESISTAP_PERFORMANCE_COUNTER_CATEGORY: return(new CounterCreationDataCollection() { CreateCounterCreationData(string.Empty, MetricsConstants.KINESISTAP_BUILD_NUMBER, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SOURCE_FACTORIES_LOADED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SOURCE_FACTORIES_FAILED_TO_LOAD, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SINK_FACTORIES_LOADED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SINK_FACTORIES_FAILED_TO_LOAD, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SINKS_STARTED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SINKS_FAILED_TO_START, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SOURCES_STARTED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SOURCES_FAILED_TO_START, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.PIPES_CONNECTED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.PIPES_FAILED_TO_CONNECT, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.SELF_UPDATE_FREQUENCY, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.CONFIG_RELOAD_COUNT, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.CONFIG_RELOAD_FAILED_COUNT, PerformanceCounterType.NumberOfItems32) }); case KINESISTAP_PERFORMANCE_COUNTER_SOURCES_CATEGORY: return(new CounterCreationDataCollection() { CreateCounterCreationData(string.Empty, MetricsConstants.DIRECTORY_SOURCE_BYTES_TO_READ, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.DIRECTORY_SOURCE_FILES_TO_PROCESS, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.DIRECTORY_SOURCE_BYTES_READ, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.DIRECTORY_SOURCE_RECORDS_READ, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.EVENTLOG_SOURCE_EVENTS_READ, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(string.Empty, MetricsConstants.EVENTLOG_SOURCE_EVENTS_ERROR, PerformanceCounterType.NumberOfItems32), }); case KINESISTAP_PERFORMANCE_COUNTER_SINKS_CATEGORY: CounterCreationDataCollection counterData = new CounterCreationDataCollection(); string[] prefixes = new string[] { MetricsConstants.CLOUDWATCHLOG_PREFIX, MetricsConstants.KINESIS_FIREHOSE_PREFIX, MetricsConstants.KINESIS_STREAM_PREFIX }; foreach (string prefix in prefixes) { CounterCreationDataCollection sinkCounterData = new CounterCreationDataCollection() { CreateCounterCreationData(prefix, MetricsConstants.RECOVERABLE_SERVICE_ERRORS, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.NONRECOVERABLE_SERVICE_ERRORS, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.RECORDS_ATTEMPTED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.BYTES_ATTEMPTED, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.RECORDS_SUCCESS, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.RECORDS_FAILED_RECOVERABLE, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.RECORDS_FAILED_NONRECOVERABLE, PerformanceCounterType.NumberOfItems32), CreateCounterCreationData(prefix, MetricsConstants.LATENCY, PerformanceCounterType.NumberOfItems32), }; counterData.AddRange(sinkCounterData); } return(counterData); default: throw new NotImplementedException($"Category {category} not implemented"); } }