/// <summary>
 /// Remueve la instancia <paramref name="instanceName"/> de la lista de instancias
 /// </summary>
 /// <param name="categoryName">Nombre el contador que contiene la instancia</param>
 /// <param name="counterName">Nombre el contador que contiene la instancia</param>
 /// <param name="instanceName">Nombre de la instancia a quitar</param>
 public static void RemoveCounterInstance(string categoryName, string counterName, string instanceName)
 {
     if (!isInitialized)
     {
         PerformanceCounterContainer.RemoveCounterInstance(categoryName, counterName, instanceName);
     }
 }
Beispiel #2
0
 /// <summary>
 /// Instala los contadores de performance activos de la lista de contadores en el sistema,
 /// o los desinstala en caso de no estar activos
 /// </summary>
 private static void InstallPerformanceCounters()
 {
     try
     {
         foreach (CounterCategoryData category in
                  PerformanceCounterContainer.GetAllCategories())
         {
             if (!PerformanceCounterCategory.Exists(category.Name))
             {
                 if (category.IsActive)
                 {
                     InstallPerformanceCounterCategory(category);
                 }
             }
             else
             {
                 if (!category.IsActive)
                 {
                     UninstallPerformanceCounterCategory(category);
                 }
             }
         }
     }
     catch (UnauthorizedAccessException uex)
     {
         throw new InstrumentationException(Messages.InsufficientPermissionsForCounterReading, uex);
     }
 }
Beispiel #3
0
 /// <summary>
 /// Desinstala todos los contadores de la aplicación
 /// </summary>
 public static void UninstallAllApplicationCounters()
 {
     foreach (CounterCategoryData category in PerformanceCounterContainer.GetAllCategories())
     {
         UninstallPerformanceCounterCategory(category);
     }
 }
Beispiel #4
0
        /// <summary>
        /// Carga la configuración por defecto
        /// </summary>
        private static void LoadConfigurationFromDefaultConfiguration()
        {
            string defaultCategoryName        = "Alemana";
            string defaultCategoryDescription = "Contadores de Alemana";

            PerformanceCounterContainer.AddPerformanceCounterCategory(defaultCategoryName,
                                                                      defaultCategoryDescription, true,
                                                                      PerformanceCounterCategoryType.MultiInstance);
        }
 /// <summary>
 /// Quita el contador <paramref name="counterName"/> de la categoría <paramref name="categoryName"/>
 /// </summary>
 /// <param name="categoryName">Nombre de la categoría</param>
 /// <param name="counterName">Nombre del contador</param>
 public static void RemoveCounter(string categoryName, string counterName)
 {
     if (!isInitialized)
     {
         PerformanceCounterContainer.RemoveCounter(categoryName, counterName);
     }
     else
     {
         throw new InstrumentationException(
                   "El InstrumentationProvider ya está inicializado. Debe llamar a este método antes de llamar a Initialize()");
     }
 }
        /// <summary>
        /// Incrementa en 1 la instancia del contador especificado
        /// </summary>
        /// <param name="categoryName">Nombre de la categoría del contador</param>
        /// <param name="counterName">Nombre del contador</param>
        /// <param name="instanceName">Nombre de la instancia del contador</param>
        public static void IncreaseCounter(string categoryName, string counterName,
                                           string instanceName)
        {
            if (isInitialized)
            {
                CounterInstanceData instanceData =
                    PerformanceCounterContainer.GetPerformanceCounterInstance(categoryName, counterName, instanceName);

                if (instanceData != null)
                {
                    instanceData.IncreaseCounter();
                }
            }
        }
Beispiel #7
0
        /// <summary>
        /// Carga la configuración a partir de <paramref name="section"/>
        /// </summary>
        /// <param name="section">Sección de configuración del archivo de configuración</param>
        private static void LoadConfigurationFromConfigurationSection(
            InstrumentationSection section)
        {
            foreach (PerformanceCounterCategoryElement categoryElement in section.CategoryCollection)
            {
                PerformanceCounterContainer.AddPerformanceCounterCategory(categoryElement.Name,
                                                                          categoryElement.Description, categoryElement.IsActive, categoryElement.Type);

                foreach (PerformanceCounterElement counterElement in categoryElement.PerformanceCounterCollection)
                {
                    PerformanceCounterContainer.AddCounter(categoryElement.Name,
                                                           counterElement.Name, counterElement.Description, counterElement.Type);

                    foreach (PerformanceCounterInstanceElement instanceElement in counterElement.InstanceCollection)
                    {
                        PerformanceCounterContainer.AddCounterInstance(categoryElement.Name, counterElement.Name,
                                                                       instanceElement.Name, instanceElement.IsActive);
                    }
                }
            }
        }
        /// <summary>
        /// Registra la diferencia de tiempo entre <paramref name="startTime"/> y el momento en que
        /// se llama a la operación. El contador debe ser de tipo Average.
        /// </summary>
        /// <param name="categoryName">Nombre de la categoría del contador</param>
        /// <param name="counterName">Nombre del contador</param>
        /// <param name="instanceName">Nombre de la instancia del contador</param>
        /// <param name="startTime">Instante inicial que se usará para comparar con el momento
        /// actual para calcular la diferencia entre ambos e incrementar el contador acorde</param>
        public static void RegisterTime(string categoryName, string counterName,
                                        string instanceName, DateTime startTime)
        {
            if (isInitialized)
            {
                CounterData counterData =
                    PerformanceCounterContainer.GetCounter(categoryName, counterName);

                if (counterData != null)
                {
                    if (!counterData.HasBaseCounter)
                    {
                        throw new InstrumentationException(Messages.InvalidCounterForOperation);
                    }

                    if (counterData.HasInstance(instanceName))
                    {
                        counterData.GetInstance(instanceName).RegisterTime(startTime);
                    }
                }
            }
        }
Beispiel #9
0
        /// <summary>
        /// Crea las instancias de contadores
        /// </summary>
        private static void InitializeCounters()
        {
            foreach (CounterCategoryData category in PerformanceCounterContainer.GetAllCategories())
            {
                if (category.IsActive)
                {
                    foreach (CounterData counterData in category.GetAllCounters())
                    {
                        foreach (CounterInstanceData instanceData in counterData.GetAllInstances())
                        {
                            using (PerformanceCounter counter = new PerformanceCounter(category.Name, counterData.Name, instanceData.Name, false))
                            {
                                instanceData.RealCounter = counter;

                                if (!instanceData.IsActive)
                                {
                                    counter.RemoveInstance();
                                }

                                if (counterData.HasBaseCounter)
                                {
                                    using (PerformanceCounter baseCounter = new PerformanceCounter(category.Name, counterData.BaseName, instanceData.Name, false))
                                    {
                                        instanceData.RealCounterBase = baseCounter;

                                        if (!instanceData.IsActive)
                                        {
                                            baseCounter.RemoveInstance();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 /// <summary>
 /// Indica si se tiene la instancia especificada
 /// </summary>
 /// <param name="categoryName">Nombre de la categoría</param>
 /// <param name="counterName">Nombre del contador</param>
 /// <param name="instanceName">Nombre de la instancia</param>
 /// <returns>Si contiene o no la intancia</returns>
 public static bool HasCounterInstance(string categoryName, string counterName, string instanceName)
 {
     return(PerformanceCounterContainer.HasCounterInstance(categoryName, counterName, instanceName));
 }