Esempio n. 1
0
        public static void PerformanceCounterCategory_CounterExists_Invalid()
        {
            PerformanceCounterCategory pcc = new PerformanceCounterCategory();

            Assert.Throws <ArgumentNullException>(() => pcc.CounterExists(null));
            Assert.Throws <InvalidOperationException>(() => pcc.CounterExists("Interrupts/sec"));
        }
Esempio n. 2
0
 public bool RemovePerformanceCounter(string counterName)
 {
     if (!_category.CounterExists(counterName))
     {
         return(false);
     }
     if (!_counters.ContainsKey(counterName))
     {
         return(true);
     }
     _counters[counterName].Dispose();
     _counters.Remove(counterName);
     _beanInfoDirty = true;
     return(true);
 }
Esempio n. 3
0
        private static Dictionary <string, PerformanceCounter> GetCounters(string processName)
        {
            var perfCounters = new Dictionary <string, PerformanceCounter>();

            if (PerformanceCounterCategory.Exists("Process"))
            {
                if (PerformanceCounterCategory.CounterExists("Working Set", "Process"))
                {
                    perfCounters.Add("Working Set", new PerformanceCounter("Process", "Working Set", processName, true));
                }

                if (PerformanceCounterCategory.CounterExists("% Processor Time", "Process"))
                {
                    perfCounters.Add("CPU", new PerformanceCounter("Process", "% Processor Time", processName, true));
                }
            }

            if (PerformanceCounterCategory.Exists("Memory"))
            {
                if (PerformanceCounterCategory.CounterExists("Available Mbytes", "Memory"))
                {
                    perfCounters.Add("Available Memory", new PerformanceCounter("Memory", "Available Mbytes", true));
                }
            }

            return(perfCounters);
        }
        private static IPerformanceCounter GetInstance(PerformanceCounterCategoryAttribute categoryAttribute,
                                                       PerformanceCounterAttribute counterAttribute, bool readOnly)
        {
            var categoryName = categoryAttribute.CategoryName;
            var categoryType = categoryAttribute.CategoryType;
            var counterName  = counterAttribute.CounterName;
            var counterType  = counterAttribute.CounterType;

            try
            {
                if (PerformanceCounterCategory.Exists(categoryName) &&
                    PerformanceCounterCategory.CounterExists(counterName, categoryName))
                {
                    var instanceName = categoryType == PerformanceCounterCategoryType.SingleInstance
                                                                   ? string.Empty
                                                                   : Process.GetCurrentProcess().ProcessName;

                    var counter = new PerformanceCounter(categoryName, counterName, instanceName, readOnly);
                    return(new PerformanceCounterProxy(counter));
                }
            }
            catch
            {
            }

            return(new NullPerformanceCounter(counterName, counterType));
        }
Esempio n. 5
0
        public static string GetInstanceName(Process process)
        {
            var counterName  = ToString(CounterName.ProcessID);
            var categoryName = ToString(CategoryName.Process);

            if (PerformanceCounterCategory.CounterExists(counterName, categoryName))
            {
                Process[] processes = Process.GetProcessesByName(process.ProcessName);
                if (processes.Length > 0)
                {
                    for (var i = processes.Length - 1; i >= 0; i--)
                    {
                        var instanceName = i == 0 ? process.ProcessName : process.ProcessName + "#" + i;

                        try
                        {
                            using (var counter = new PerformanceCounter(categoryName, counterName, instanceName))
                            {
                                if (process.Id == counter.RawValue)
                                {
                                    return(instanceName);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Util.Logging.Log(ex);
                        }
                    }
                }
            }

            return(null);
        }
Esempio n. 6
0
        static void Monitor(string category, string counter, string instance, EventWaitHandle stopper)
        {
            if (!PerformanceCounterCategory.Exists(category))
            {
                throw new InvalidOperationException("Kategoria nie istnieje");
            }
            if (!PerformanceCounterCategory.CounterExists(counter, category))
            {
                throw new InvalidOperationException("Licznik nie istnieje");
            }
            if (instance == null)
            {
                instance = "";
            }
            if (instance != "" && !PerformanceCounterCategory.InstanceExists(instance, category))
            {
                throw new InvalidOperationException("Egzemplarz nie istnieje.");
            }
            float lastValue = 0f;

            using (PerformanceCounter pc = new PerformanceCounter(category, counter, instance))
            {
                while (!stopper.WaitOne(200, false))
                {
                    float value = pc.NextValue();
                    if (!value.Equals(lastValue))
                    {
                        Console.WriteLine(category + ": " + value);
                        lastValue = value;
                    }
                }
            }
        }
Esempio n. 7
0
        private string GetInstanceName(Process process)
        {
            if (PerformanceCounterCategory.CounterExists("ID Process", "Process"))
            {
                Process[] processes = Process.GetProcessesByName(process.ProcessName);
                if (processes.Length > 0)
                {
                    for (var i = processes.Length - 1; i >= 0; i--)
                    {
                        string name = i == 0 ? process.ProcessName : process.ProcessName + "#" + i;

                        try
                        {
                            using (var counter = new PerformanceCounter("Process", "ID Process", name))
                            {
                                if (process.Id == counter.RawValue)
                                {
                                    return(name);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Util.Logging.Log(ex);
                        }
                    }
                }
            }

            return(null);
        }
        private string getProcessNameById(int processId)
        {
            Process process     = Process.GetProcessById(processId);
            string  processName = process.ProcessName;

            if (!string.IsNullOrEmpty(processName))
            {
                Process[] processes = Process.GetProcessesByName(processName);
                if (processes.Length > 0)
                {
                    for (int i = 0; i < processes.Length; i++)
                    {
                        string tempProcessName = i == 0 ? processName : processName + "#" + i.ToString();
                        if (PerformanceCounterCategory.CounterExists("ID Process", "Process", this.machineName))
                        {
                            PerformanceCounter idCounter = new PerformanceCounter("Process", "ID Process", tempProcessName, this.machineName);
                            if (processId == idCounter.RawValue)
                            {
                                return(tempProcessName);
                            }
                        }
                    }
                }
            }
            return(string.Empty);
        }
        private static void LazyCreatePerformanceCounter(PerformanceCounterHolder holder, TelemetryData data)
        {
            if (holder.Counter != null)
            {
                return;
            }

            // If counter does not exist then it's probably an installation problem:
            // * counters have not been created and TelemetrySession.Start did it but OS didn't refresh them yet;
            // * category already existed but a new version added more counters and old category has not been properly uninstalled.
            if (!PerformanceCounterCategory.CounterExists(data.Name, data.Category))
            {
                holder.IsDisabled = true;
                return;
            }

            holder.Counter = new PerformanceCounter(data.Category, data.Name, false);

            if (data.CounterType == TelemetryDataType.AverageCount)
            {
                // Base PC name convention: keep in sync with code in WpcTelemetrySessionInstaller
                holder.Base = new PerformanceCounter(data.Category, data.Name + "Base", false);

                holder.Counter.RawValue = 0;
                holder.Base.RawValue    = 0;
            }
        }
        /// <summary>
        /// The get performance counter value.
        /// </summary>
        /// <param name="counterCategory">
        /// The counter category.
        /// </param>
        /// <param name="counterName">
        /// The counter name.
        /// </param>
        /// <param name="instanceName">
        /// The instance name.
        /// </param>
        /// <param name="logger">
        /// The logger.
        /// </param>
        /// <returns>
        /// The <see cref="float?"/>.
        /// </returns>
        public float?GetPerfCounterValue(PerformanceCounterCategory counterCategory, string counterName, string instanceName, ILog logger)
        {
            try
            {
                if (counterCategory == null)
                {
                    logger.ErrorFormat("Performance counter category: '{0}' is not exist.", counterCategory);
                    return(null);
                }
                if (counterCategory.CounterExists(counterName))
                {
                    var performanceCounter = new PerformanceCounter(counterCategory.CategoryName, counterName, instanceName);
                    using (performanceCounter)
                    {
                        return(performanceCounter.NextValue());
                    }
                }
                else
                {
                    logger.ErrorFormat("Performance counter {0} {1} is missing on server", counterCategory.CategoryName, counterName);
                }
            }
            catch (Exception exception)
            {
                logger.ErrorFormat("Error occurred while getting counter {0} for category {1}. {2}", counterName, counterCategory.CategoryName, exception);
            }

            return(null);
        }
Esempio n. 11
0
        private static void WrappedRegister(MetricsContext context, string name, Unit unit,
                                            string category, string counter, string instance = null,
                                            Func <double, double> derivate = null,
                                            MetricTags tags = default(MetricTags))
        {
            log.Debug(() => $"Registering performance counter [{counter}] in category [{category}] for instance [{instance ?? "none"}]");

            if (PerformanceCounterCategory.Exists(category))
            {
                if (instance == null || PerformanceCounterCategory.InstanceExists(instance, category))
                {
                    if (PerformanceCounterCategory.CounterExists(counter, category))
                    {
                        var counterTags = new MetricTags(tags.Tags.Concat(new[] { "PerfCounter" }));
                        if (derivate == null)
                        {
                            context.Advanced.Gauge(name, () => new PerformanceCounterGauge(category, counter, instance), unit, counterTags);
                        }
                        else
                        {
                            context.Advanced.Gauge(name, () => new DerivedGauge(new PerformanceCounterGauge(category, counter, instance), derivate), unit, counterTags);
                        }
                        return;
                    }
                }
            }

            if (!isMono)
            {
                log.ErrorFormat("Performance counter does not exist [{0}] in category [{1}] for instance [{2}]", counter, category, instance ?? "none");
            }
        }
        public void RemoveInstancesAndDispose_MultiInstanceCounters_Works(int numOfCounters)
        {
            // Arrange
            var helpers = new List <CounterHelper <MultiInstanceCategory> >();

            for (int i = 0; i < numOfCounters; i++)
            {
                var instanceName = GetInstanceName(i);
                helpers.Add(PerformanceHelper.CreateCounterHelper <MultiInstanceCategory>(instanceName));
            }

            //Act
            helpers.ForEach(helper => helper.RemoveInstancesAndDispose());

            // Assert
            for (int i = 0; i < numOfCounters; i++)
            {
                // The counters still exist
                Assert.IsTrue(PerformanceCounterCategory.CounterExists(AvgCounterName, CategoryName));
                Assert.IsTrue(PerformanceCounterCategory.CounterExists(NumCounterName, CategoryName));

                // The instances should NOT
                Assert.IsFalse(
                    PerformanceCounterCategory.InstanceExists(GetInstanceName(i), CategoryName),
                    string.Format("{0} should not exist anymore", GetInstanceName(i)));

                var category      = PerformanceCounterCategory.GetCategories().First(cat => cat.CategoryName == CategoryName);
                var instanceNames = category.GetInstanceNames().OrderBy(name => name).ToArray();
                Assert.AreEqual(0, instanceNames.Count(), "There should be no instances left");
            }
        }
Esempio n. 13
0
        void InitiatizeCategory()
        {
            try
            {
                var counters = new[]
                {
                    ConsumerThreadCount,
                    ReceiveThreadCount,
                    ReceiveRate,
                    PublishRate,
                    SendRate,
                    ReceiveCount,
                    PublishCount,
                    SentCount,
                    ConsumerDuration,
                    ConsumerDurationBase,
                    ReceiveDuration,
                    ReceiveDurationBase,
                    PublishDuration,
                    PublishDurationBase,
                };

                if (!PerformanceCounterCategory.Exists(CategoryName))
                {
                    PerformanceCounterCategory.Create(
                        CategoryName,
                        CategoryHelp,
                        PerformanceCounterCategoryType.MultiInstance,
                        new CounterCreationDataCollection(counters.Select(x => (CounterCreationData)x).ToArray()));

                    return;
                }

                int missing = counters
                              .Where(counter => !PerformanceCounterCategory.CounterExists(counter.Name, CategoryName))
                              .Count();

                if (missing > 0)
                {
                    PerformanceCounterCategory.Delete(CategoryName);

                    PerformanceCounterCategory.Create(
                        CategoryName,
                        CategoryHelp,
                        PerformanceCounterCategoryType.MultiInstance,
                        new CounterCreationDataCollection(counters.Select(x => (CounterCreationData)x).ToArray()));
                }
            }
            catch (SecurityException)
            {
                //swallow the exception because having these is NOT critical

                var msg =
                    "Unable to create performance counter category (Category: {0})" +
                    "\nTry running the program in the Administrator role to set these up." +
                    "\n**Hey, this just means you aren't admin or don't have/want perf counter support**"
                    .FormatWith(CategoryName);
                _log.Warn(msg);
            }
        }
        void Initialize()
        {
#if !NETCORE
            try
            {
                var counters = Data.Select(x => x.ToCounterCreationData());

                if (!PerformanceCounterCategory.Exists(_categoryName))
                {
                    CreateCategory(counters);

                    return;
                }

                IEnumerable <CounterCreationData> missing =
                    counters.Where(counter => !PerformanceCounterCategory.CounterExists(counter.CounterName, _categoryName));

                if (missing.Any())
                {
                    PerformanceCounterCategory.Delete(_categoryName);

                    CreateCategory(counters);
                }
            }
            catch (SecurityException exception)
            {
                LogContext.Warning?.Log(exception, "Unable to create performance counter category (Category: {Category})" +
                                        "\nTry running the program in the Administrator role to set these up." +
                                        "\n**Hey, this just means you aren't admin or don't have/want perf counter support**", _categoryName);
            }
#endif
        }
Esempio n. 15
0
        protected void CreateCounters()
        {
            var categoryExists = false;

            // check if all the perf counters exist - this is the best that can be done with the current API
            if ((categoryExists = PerformanceCounterCategory.Exists(_categoryName)) &&
                _counterDefinitions.Cast <CounterCreationData>().All(ccd => PerformanceCounterCategory.CounterExists(ccd.CounterName, _categoryName)))
            {
                return;
            }

            try
            {
                if (categoryExists)
                {
                    PerformanceCounterCategory.Delete(_categoryName);
                }

                PerformanceCounterCategory.Create(_categoryName, _categoryHelp, _categoryType, _counterDefinitions);
            }
            catch (UnauthorizedAccessException e)
            {
                DerivedLogger.Error(e, "Error creating the performance counter category named '{0}'. Ensure the process is running with the necessary privileges.", _categoryName);
            }
            catch (SecurityException e)
            {
                DerivedLogger.Error(e, "Error creating the performance counter category named '{0}'. Ensure the process is running with the necessary privileges.", _categoryName);
            }
            catch (Exception e)
            {
                DerivedLogger.Error(e, "Unexpected error creating the performance counter category named '{0}': {1}", _categoryName, e.Message);
            }
        }
Esempio n. 16
0
        protected static PerformanceCounter GetPerformanceCounter(string categoryName, string counterName, string instanceName)
        {
            const string runCommandMessage = "Run the following command to create it:"
                                             + " LinkMe.Framework.Environment.Util.exe /createPerf /i"
                                             + @" Tools\Performance\Config\LinkMe.Framework.Tools.Performance.Counters.config";

            try
            {
                return(new PerformanceCounter(categoryName, counterName, instanceName, false));
            }
            catch (Exception ex)
            {
                if (!PerformanceCounterCategory.Exists(categoryName))
                {
                    throw new ApplicationException("Performance counter category '" + categoryName
                                                   + "' does not exist. " + runCommandMessage, ex);
                }
                if (!PerformanceCounterCategory.CounterExists(counterName, categoryName))
                {
                    throw new ApplicationException("Performance counter '" + counterName + "' in category '"
                                                   + categoryName + "' does not exist ." + runCommandMessage, ex);
                }

                throw new ApplicationException("Failed to get performance counter '" + counterName + "' in category '"
                                               + categoryName + "'.", ex);
            }
        }
Esempio n. 17
0
 public long GetDatabaseTransactionVersionSizeInBytes()
 {
     try
     {
         const string categoryName = "Database ==> Instances";
         if (PerformanceCounterCategory.Exists(categoryName) == false)
         {
             return(-1);
         }
         var          category      = new PerformanceCounterCategory(categoryName);
         var          instances     = category.GetInstanceNames();
         var          ravenInstance = instances.FirstOrDefault(x => x.StartsWith(uniqueRrefix));
         const string counterName   = "Version Buckets Allocated";
         if (ravenInstance == null || !category.CounterExists(counterName))
         {
             return(-2);
         }
         using (var counter = new PerformanceCounter(categoryName, counterName, ravenInstance, readOnly: true))
         {
             var value = counter.NextValue();
             return((long)(value * TransactionalStorageConfigurator.GetVersionPageSize()));
         }
     }
     catch (Exception e)
     {
         if (reportedGetDatabaseTransactionCacheSizeInBytesError == false)
         {
             reportedGetDatabaseTransactionCacheSizeInBytesError = true;
             log.WarnException("Failed to get Version Buckets Allocated value, this error will only be reported once.", e);
         }
         return(-3);
     }
 }
Esempio n. 18
0
 public static void PerformanceCounterCategory_CounterExists_StaticInvalid()
 {
     Assert.Throws <ArgumentNullException>(() => PerformanceCounterCategory.CounterExists(null, "Processor"));
     Assert.Throws <ArgumentNullException>(() => PerformanceCounterCategory.CounterExists("Interrupts/sec", null));
     Assert.Throws <ArgumentException>(() => PerformanceCounterCategory.CounterExists("Interrupts/sec", string.Empty));
     Assert.Throws <ArgumentException>(() => PerformanceCounterCategory.CounterExists("Interrupts/sec", "Processor", string.Empty));
 }
        void Initialize()
        {
            try
            {
                CounterCreationData[] counters = Data;

                if (!PerformanceCounterCategory.Exists(_categoryName))
                {
                    CreateCategory(counters);

                    return;
                }

                IEnumerable <CounterCreationData> missing =
                    counters.Where(counter => !PerformanceCounterCategory.CounterExists(counter.CounterName, _categoryName));
                if (missing.Any())
                {
                    PerformanceCounterCategory.Delete(_categoryName);

                    CreateCategory(counters);
                }
            }
            catch (SecurityException)
            {
                _log.WarnFormat(
                    "Unable to create performance counter category (Category: {0})" +
                    "\nTry running the program in the Administrator role to set these up." +
                    "\n**Hey, this just means you aren't admin or don't have/want perf counter support**", _categoryName);
            }
        }
Esempio n. 20
0
 public static long?SafelyGetPerformanceCounter(string categoryName, string counterName, string processName)
 {
     try
     {
         if (PerformanceCounterCategory.Exists(categoryName) == false)
         {
             return(null);
         }
         var category      = new PerformanceCounterCategory(categoryName);
         var instances     = category.GetInstanceNames();
         var ravenInstance = instances.FirstOrDefault(x => x == processName);
         if (ravenInstance == null || !category.CounterExists(counterName))
         {
             return(null);
         }
         using (var counter = new PerformanceCounter(categoryName, counterName, ravenInstance, readOnly: true))
         {
             return(counter.NextSample().RawValue);
         }
     }
     catch (Exception)
     {
         //Don't log anything here, it's up to the calling code to decide what to do
         return(null);
     }
 }
        public static void Monitor(string categroy, string counter, string instance, EventWaitHandle stopper)
        {
            if (!PerformanceCounterCategory.Exists(categroy))
            {
                throw new InvalidOperationException("Categroy does not exist");
            }
            if (!PerformanceCounterCategory.CounterExists(counter, categroy))
            {
                throw new InvalidOperationException("Counter does not exist");
            }

            instance ??= "";
            if (instance != "" && !PerformanceCounterCategory.InstanceExists(instance, categroy))
            {
                throw new InvalidOperationException("Instance does not exist");
            }

            var lastValue = 0f;

            using (var pc = new PerformanceCounter(categroy, counter, instance))
            {
                //每200毫秒轮询一次
                while (!stopper.WaitOne(200, false))
                {
                    var value = pc.NextValue();
                    if (System.Math.Abs(value - lastValue) > 0)
                    {
                        Console.WriteLine(value);
                        lastValue = value;
                    }
                }
            }
        }
Esempio n. 22
0
        public PerfCounter(string category, string name)
        {
            Category = category;
            Name     = name;

            bool catExists = PerformanceCounterCategory.Exists(Category);
            bool exists    = catExists && PerformanceCounterCategory.CounterExists(name, Category);

            if (!exists)
            {
                #if DEBUG
                if (!catExists)
                {
                    MessageBox.Show($"Failed to find Category {Category}");
                }
                else
                {
                    MessageBox.Show($"Failed to find Counter {name}");
                }
                #endif

                return;
            }

            PerformanceCounterCategory counterCategory = new PerformanceCounterCategory(Category);

            string[] names = counterCategory.GetInstanceNames();
            m_counter = new PerformanceCounter[names.Length];
            for (int i = 0; i < names.Length; i++)
            {
                m_counter[i] = new PerformanceCounter(Category, Name, names[i], true);
            }
        }
        private static void CheckCounters()
        {
            try
            {
                if (!PerformanceCounterCategory.Exists(PERFORMANCE_COUNTER_CATEGORY_NAME))
                {
                    CreateCategory();
                }
                else
                {
                    foreach (var counter in m_counterNames)
                    {
                        if (!PerformanceCounterCategory.CounterExists(counter.Key, PERFORMANCE_COUNTER_CATEGORY_NAME))
                        {
                            CreateCategory();
                            break;
                        }
                    }
                }

                m_sipsorceryCategoryReady = true;
            }
            catch (Exception excp)
            {
                logger.Error("Exception SIPSorceryPerformanceMonitor CheckCounters. " + excp.Message);
            }
        }
Esempio n. 24
0
        public static void EnsureCategory(IICPerformanceCountersAttribute categoryAttr, IEnumerable <IICPerformanceCounter> counters)
        {
            bool needCreate;

            if (!PerformanceCounterCategory.Exists(categoryAttr.CategoryName))
            {
                needCreate = true;
            }
            else
            {
                needCreate = false;
                foreach (IICPerformanceCounter counter in counters)
                {
                    if (!PerformanceCounterCategory.CounterExists(counter._rawAttr.CounterName, categoryAttr.CategoryName))
                    {
                        needCreate = true;
                        break;
                    }
                }

                if (needCreate)
                {
                    PerformanceCounterCategory.Delete(categoryAttr.CategoryName);
                }
            }

            if (needCreate)
            {
                CreateCategory(categoryAttr, counters);
            }
        }
Esempio n. 25
0
        private static bool PerformanceCounterExistsAndHasAllCounters(string instanceName)
        {
            if (PerformanceCounterCategory.Exists(CategoryName) == false)
            {
                return(false);
            }
            foreach (var counter in CounterProperties)
            {
                if (PerformanceCounterCategory.CounterExists(counter.Name, CategoryName) == false)
                {
                    PerformanceCounterCategory.Delete(CategoryName);
                    return(false);
                }

                try
                {
                    new PerformanceCounter(CategoryName, counter.Name, instanceName, readOnly: true).Close();
                }
                catch (InvalidOperationException)
                {
                    PerformanceCounterCategory.Delete(CategoryName);
                    return(false);
                }
            }

            return(true);
        }
        private void CreateIfNotExists(IEnumerable <CounterCreationData> totalCounterCreationDatas)
        {
            // размножаем счетчики по именам операций
            var multipliedBtOperations = operations
                                         .SelectMany(op => totalCounterCreationDatas.Select(ccd => new CounterCreationData()
            {
                CounterHelp = ccd.CounterHelp,
                CounterName = PerOperationCounter.CounterNameForOperation(ccd.CounterName, op),
                CounterType = ccd.CounterType
            })).Union(totalCounterCreationDatas).ToArray();

            // если ес ть хотя бы один не зарегистрированный счетчик
            if (!PerformanceCounterCategory.Exists(MidwayClientCategoryName) || multipliedBtOperations.Any(
                    d => !PerformanceCounterCategory.CounterExists(d.CounterName, MidwayClientCategoryName)))
            {
                // удаляем категорию и регистрируем сноваt
                if (PerformanceCounterCategory.Exists(MidwayClientCategoryName))
                {
                    PerformanceCounterCategory.Delete(MidwayClientCategoryName);
                }

                var counterCreationDataCollection = new CounterCreationDataCollection(multipliedBtOperations.ToArray());

                PerformanceCounterCategory.Create(MidwayClientCategoryName,
                                                  "Счетчики производительности веб-сервиса обмена",
                                                  PerformanceCounterCategoryType.SingleInstance,
                                                  counterCreationDataCollection);
            }
        }
        public static bool CanFindPerformanceCounter(PerformanceCounterMetricName name)
        {
            var hasInstance = !string.IsNullOrEmpty(name.InstanceName);

            return(hasInstance
                ? PerformanceCounterCategory.InstanceExists(name.InstanceName, name.CategoryName)
                : PerformanceCounterCategory.CounterExists(name.CounterName, name.CategoryName));
        }
Esempio n. 28
0
        public static PerformanceCounter GetCounter(string category, string counter, string name)
        {
            if (PerformanceCounterCategory.Exists(category) && PerformanceCounterCategory.CounterExists(counter, category))
            {
                return(new PerformanceCounter(category, counter, name, true));
            }

            return(null);
        }
Esempio n. 29
0
        /// <summary>
        /// Determines whether the item is installed.
        /// </summary>
        /// <param name="installationContext">The installation context.</param>
        /// <returns>
        /// Value indicating whether the item is installed or null if it is not possible to determine.
        /// </returns>
        public bool?IsInstalled(InstallationContext installationContext)
        {
            if (!PerformanceCounterCategory.Exists(CategoryName))
            {
                return(false);
            }

            return(PerformanceCounterCategory.CounterExists(CounterName, CategoryName));
        }
Esempio n. 30
0
        private PerformanceSampler(string instanceName)
        {
            if (_disablePerformanceSampling)
            {
                return;
            }

            if (PerformanceCounterCategory.CounterExists(PerformanceCounters.TotalMessagesReceived, PerformanceCounters.CategoryName) &&
                PerformanceCounterCategory.CounterExists(PerformanceCounters.MessagesReceivedRate, PerformanceCounters.CategoryName))
            {
                this.totalMessagesReceived = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.TotalMessagesReceived, instanceName, true);
                this.messagesReceivedRate  = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.MessagesReceivedRate, instanceName, true);
            }
            else
            {
                logger.WarnFormat("The Performance Counters {0} and {1} are not installed. This sampler will be disabled.", PerformanceCounters.TotalMessagesReceived, PerformanceCounters.MessagesReceivedRate);
                _disableMessagesReceived = true;
            }

            if (PerformanceCounterCategory.CounterExists(PerformanceCounters.TotalMessagesSent, PerformanceCounters.CategoryName) &&
                PerformanceCounterCategory.CounterExists(PerformanceCounters.MessagesSentRate, PerformanceCounters.CategoryName))
            {
                this.totalMessagesSent = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.TotalMessagesSent, instanceName, true);
                this.messagesSentRate  = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.MessagesSentRate, instanceName, true);
            }
            else
            {
                logger.WarnFormat("The Performance Counters {0} and {1} are not installed. This sampler will be disabled.", PerformanceCounters.TotalMessagesSent, PerformanceCounters.MessagesSentRate);
                _disableMessagesSent = true;
            }

            if (PerformanceCounterCategory.CounterExists(PerformanceCounters.TotalMessageFailures, PerformanceCounters.CategoryName) &&
                PerformanceCounterCategory.CounterExists(PerformanceCounters.MessageFailureRate, PerformanceCounters.CategoryName))
            {
                this.totalMessageFailures = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.TotalMessageFailures, instanceName, true);
                this.messageFailureRate   = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.MessageFailureRate, instanceName, true);
            }
            else
            {
                logger.WarnFormat("The Performance Counters {0} and {1} are not installed. This sampler will be disabled.", PerformanceCounters.TotalMessageFailures, PerformanceCounters.MessageFailureRate);
                _disableMessageFailure = true;
            }

            if (PerformanceCounterCategory.CounterExists(PerformanceCounters.AvgMessageHandlingDuration, PerformanceCounters.CategoryName) &&
                PerformanceCounterCategory.CounterExists(PerformanceCounters.AvgMessageHandlingDurationBase, PerformanceCounters.CategoryName))
            {
                this.avgMessageHandlingDuration     = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.AvgMessageHandlingDuration, instanceName, true);
                this.avgMessageHandlingDurationBase = new PerformanceCounter(PerformanceCounters.CategoryName, PerformanceCounters.AvgMessageHandlingDurationBase, instanceName, true);
            }
            else
            {
                logger.WarnFormat("The Performance Counters {0} and {1} are not installed. This sampler will be disabled.", PerformanceCounters.AvgMessageHandlingDuration, PerformanceCounters.AvgMessageHandlingDurationBase);
                _disableAvgMessageHandling = true;
            }
        }