upstream/icinga-powershell-framework
1
0
Fork 0
mirror of https://github.com/Icinga/icinga-powershell-framework.git synced 2025-12-21 07:10:15 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added Performance Counter Library as module handlers

Browse source
This commit is contained in:
Lord Hepipud 2019-07-22 13:17:07 +02:00
parent 8ef18f97a9
commit 164f03343c
8 changed files with 516 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
lib/core/perfcounter/New-IcingaPerformanceCounter.psm1 Normal file
View file

@ -0,0 +1,108 @@
<#
# This is the main function which is called from this script, constructing our counters
# and loading possible sub-instances from our Performance Counter.
# It will return either an New-IcingaPerformanceCounterObject or New-IcingaPerformanceCounterArray
# which both contain the same members, allowing us to dynamicly use the objects
# without having to worry about exception.
#>
function New-IcingaPerformanceCounter()
{
param(
[string]$Counter = '',
[boolean]$SkipWait = $FALSE
);
# Simply use the counter name, like
# \Paging File(_total)\% Usage
if ([string]::IsNullOrEmpty($Counter) -eq $TRUE) {
return (New-IcingaPerformanceCounterNullObject -FullName $Counter -ErrorMessage 'Failed to initialise counter, as no counter was specified.');
}
[array]$CounterArray = $Counter.Split('\');
[string]$UseCounterCategory = '';
[string]$UseCounterName = '';
[string]$UseCounterInstance = '';
# If we add the counter as it should be
# \Paging File(_total)\% Usage
# the first array element will be an empty string we can skip
# Otherwise the name was wrong and we should not continue
if (-Not [string]::IsNullOrEmpty($CounterArray[0])) {
return (New-IcingaPerformanceCounterNullObject -FullName $Counter -ErrorMessage ([string]::Format('Failed to deserialize counter "{0}". It seems the leading "\" is missing.', $Counter)));
}
# In case our Performance Counter is containing instances, we should split
# The content and read the instance and counter category out
if ($CounterArray[1].Contains('(')) {
[array]$TmpCounter = $CounterArray[1].Split('(');
$UseCounterCategory = $TmpCounter[0];
$UseCounterInstance = $TmpCounter[1].Replace(')', '');
} else {
# Otherwise we only require the category
$UseCounterCategory = $CounterArray[1];
}
# At last get the actual counter containing our values
$UseCounterName = $CounterArray[2];
# Now as we know how the counter path is constructed and has been splitted into
# the different values, we need to know how to handle the instances of the counter
# If we specify a instance with (*) we want the module to automaticly fetch all
# instances for this counter. This will result in an New-IcingaPerformanceCounterArray
# which contains the parent name including counters for all instances that
# have been found
if ($UseCounterInstance -eq '*') {
# In case we already loaded the counters once, return the finished array
# TODO: Re-Implement caching for counters
<#if ($Icinga2.Cache.PerformanceCounter.ContainsKey($Counter) -eq $TRUE) {
return (New-IcingaPerformanceCounterArray -FullName $Counter -PerformanceCounters $Icinga2.Cache.PerformanceCounter[$Counter]);
}#>
# If we need to build the array, load all instances from the counters and
# create single performance counters and add them to a custom array and
# later to a custom object
try {
[array]$AllCountersIntances = @();
$CounterInstances = New-Object System.Diagnostics.PerformanceCounterCategory($UseCounterCategory);
foreach ($instance in $CounterInstances.GetInstanceNames()) {
[string]$NewCounterName = $Counter.Replace('*', $instance);
$NewCounter = New-IcingaPerformanceCounterObject -FullName $NewCounterName -Category $UseCounterCategory -Counter $UseCounterName -Instance $instance -SkipWait $SkipWait;
$AllCountersIntances += $NewCounter;
}
} catch {
return (New-IcingaPerformanceCounterNullObject -FullName $Counter -ErrorMessage ([string]::Format('Failed to deserialize instances for counter "{0}". Exception: "{1}".', $Counter, $_.Exception.Message)));
}
# Add the parent counter including the array of Performance Counters to our
# caching mechanism and return the New-IcingaPerformanceCounterArray object for usage
# within the monitoring modules
# TODO: Re-Implement caching for counters
# $Icinga2.Cache.PerformanceCounter.Add($Counter, $AllCountersIntances);
return (New-IcingaPerformanceCounterArray -FullName $Counter -PerformanceCounters $AllCountersIntances);
} else {
# This part will handle the counters without any instances as well as
# specificly assigned instances, like (_Total) CPU usage.
# In case we already have the counter within our cache, return the
# cached informations
# TODO: Re-Implement caching for counters
<#if ($Icinga2.Cache.PerformanceCounter.ContainsKey($Counter) -eq $TRUE) {
return $Icinga2.Cache.PerformanceCounter[$Counter];
}#>
# If the cache is not present yet, create the Performance Counter object,
# and add it to our cache
$NewCounter = New-IcingaPerformanceCounterObject -FullName $Counter -Category $UseCounterCategory -Counter $UseCounterName -Instance $UseCounterInstance -SkipWait $SkipWait;
# TODO: Re-Implement caching for counters
#$Icinga2.Cache.PerformanceCounter.Add($Counter, $NewCounter);
return $NewCounter; #TODO: Remove once caching is implemented
}
# This function will always return non-instance counters or
# specificly defined instance counters. Performance Counter Arrays
# are returned within their function. This is just to ensure that the
# function looks finished from developer point of view
# TODO: Re-Implement caching for counters, right now we return $NewCounter by default
#return $Icinga2.Cache.PerformanceCounter[$Counter];
}

39
lib/core/perfcounter/New-IcingaPerformanceCounterArray.psm1 Normal file
View file

@ -0,0 +1,39 @@
<#
# This function will provide a virtual object, containing an array
# of Performance Counters. The object has the following members:
# Name
# Value
# This will ensure we will not have to worry about looping an array
# of mutltiple instances within a counter handler, because this
# function will deal with everything, returning an hashtable
# containing the parent counter name including the values and
# samples for every single instance
#>
function New-IcingaPerformanceCounterArray()
{
param(
[string]$FullName = '',
[array]$PerformanceCounters = @()
);
$pc_instance = New-Object -TypeName PSObject;
$pc_instance | Add-Member -membertype NoteProperty -name 'FullName' -value $FullName;
$pc_instance | Add-Member -membertype NoteProperty -name 'Counters' -value $PerformanceCounters;
$pc_instance | Add-Member -membertype ScriptMethod -name 'Name' -value {
return $this.FullName;
}
$pc_instance | Add-Member -membertype ScriptMethod -name 'Value' -value {
[hashtable]$CounterResults = @{};
foreach ($counter in $this.Counters) {
$CounterResults.Add($counter.Name(), $counter.Value());
}
return $CounterResults;
}
return $pc_instance;
}

37
lib/core/perfcounter/New-IcingaPerformanceCounterNullObject.psm1 Normal file
View file

@ -0,0 +1,37 @@
<#
# If some informations are missing, it could happen that
# we are unable to create a Performance Counter.
# In this case we will use this Null Object, containing
# the same member functions but allowing us to maintain
# stability without unwanted exceptions
#>
function New-IcingaPerformanceCounterNullObject()
{
param(
[string]$FullName = '',
[string]$ErrorMessage = ''
);
$pc_instance = New-Object -TypeName PSObject;
$pc_instance | Add-Member -membertype NoteProperty -name 'FullName' -value $FullName;
$pc_instance | Add-Member -membertype NoteProperty -name 'ErrorMessage' -value $ErrorMessage;
$pc_instance | Add-Member -membertype ScriptMethod -name 'Name' -value {
return $this.FullName;
}
$pc_instance | Add-Member -membertype ScriptMethod -name 'Value' -value {
[hashtable]$ErrorMessage = @{};
$ErrorMessage.Add('value', $null);
$ErrorMessage.Add('sample', $null);
$ErrorMessage.Add('help', $null);
$ErrorMessage.Add('type', $null);
$ErrorMessage.Add('error', $this.ErrorMessage);
return $ErrorMessage;
}
return $pc_instance;
}

108
lib/core/perfcounter/New-IcingaPerformanceCounterObject.psm1 Normal file
View file

@ -0,0 +1,108 @@
<#
# This function will create a custom Performance Counter object with
# already initialised counters, which can be accessed with the
# following members:
# Name
# Value
# Like the New-IcingaPerformanceCounterArray, this will allow to fetch the
# current values of a single counter instance including the name
# of the counter. Within the New-IcingaPerformanceCounterArray function,
# objects created by this function are used.
#>
function New-IcingaPerformanceCounterObject()
{
param(
[string]$FullName = '',
[string]$Category = '',
[string]$Instance = '',
[string]$Counter = '',
[boolean]$SkipWait = $FALSE
);
$pc_instance = New-Object -TypeName PSObject;
$pc_instance | Add-Member -membertype NoteProperty -name 'FullName' -value $FullName;
$pc_instance | Add-Member -membertype NoteProperty -name 'Category' -value $Category;
$pc_instance | Add-Member -membertype NoteProperty -name 'Instance' -value $Instance;
$pc_instance | Add-Member -membertype NoteProperty -name 'Counter' -value $Counter;
$pc_instance | Add-Member -membertype NoteProperty -name 'PerfCounter' -value $Counter;
$pc_instance | Add-Member -membertype NoteProperty -name 'SkipWait' -value $SkipWait;
$pc_instance | Add-Member -membertype ScriptMethod -name 'Init' -value {
# TODO: Re-Implement debug logging
<#$Icinga2.Log.Write(
$Icinga2.Enums.LogState.Debug,
[string]::Format('Creating new Counter for Category {0} with Instance {1} and Counter {2}. Full Name "{3}"',
$this.Category,
$this.Instance,
$this.Counter,
$this.FullName
)
);#>
# Create the Performance Counter object we want to access
$this.PerfCounter = New-Object System.Diagnostics.PerformanceCounter;
$this.PerfCounter.CategoryName = $this.Category;
$this.PerfCounter.CounterName = $this.Counter;
# Only add an instance in case it is defined
if ([string]::IsNullOrEmpty($this.Instance) -eq $FALSE) {
$this.PerfCounter.InstanceName = $this.Instance
}
# Initialise the counter
try {
$this.PerfCounter.NextValue() | Out-Null;
} catch {
# Nothing to do here, will be handled later
}
<#
# For some counters we require to wait a small amount of time to receive proper data
# Other counters do not need these informations and we do also not require to wait
# for every counter we use, once the counter is initialised within our environment.
# This will allow us to skip the sleep to speed up loading counters
#>
if ($this.SkipWait -eq $FALSE) {
Start-Sleep -Milliseconds 500;
}
}
# Return the name of the counter as string
$pc_instance | Add-Member -membertype ScriptMethod -name 'Name' -value {
return $this.FullName;
}
<#
# Return a hashtable containting the counter value including the
# Sample values for the counter itself. In case we run into an error,
# keep the counter construct but add an error message in addition.
#>
$pc_instance | Add-Member -membertype ScriptMethod -name 'Value' -value {
[hashtable]$CounterData = @{};
try {
[string]$CounterType = $this.PerfCounter.CounterType;
$CounterData.Add('value', $this.PerfCounter.NextValue());
$CounterData.Add('sample', $this.PerfCounter.NextSample());
$CounterData.Add('help', $this.PerfCounter.CounterHelp);
$CounterData.Add('type', $CounterType);
$CounterData.Add('error', $null);
} catch {
$CounterData = @{};
$CounterData.Add('value', $null);
$CounterData.Add('sample', $null);
$CounterData.Add('help', $null);
$CounterData.Add('type', $null);
$CounterData.Add('error', $_.Exception.Message);
}
return $CounterData;
}
# Initialiste the entire counter and internal handlers
$pc_instance.Init();
# Return this custom object
return $pc_instance;
}

71
lib/core/perfcounter/New-IcingaPerformanceCounterResult.psm1 Normal file
View file

@ -0,0 +1,71 @@
<#
# This function will make monitoring an entire list of
# Performance counters even more easier. We simply provide
# an array of Performance Counters to this module
# and we will receive a construct-save result of an
# hashtable with all performance counters including
# the corresponding values. In that case the code
# size decreases for larger modules.
# Example:
$counter = Get-Icinga-Counter -CounterArray @(
'\Memory\Available Bytes',
'\Memory\% Committed Bytes In Use'
);
#>
function New-IcingaPerformanceCounterResult()
{
param(
[array]$CounterArray = @()
)
[hashtable]$CounterResult = @{};
[bool]$RequireSleep = $FALSE;
foreach ($counter in $CounterArray) {
# We want to speed up things with loading, so we will check if a specified
# Counter is already cached within our hashtable. If it is not, we sleep
# at the end of the function the required 500ms and don't have to wait
# NumOfCounters * 500 milliseconds for the first runs. This will speed
# up the general loading of counters and will not require some fancy
# pre-caching / configuration handler
# TODO: Re-Implement caching for counters
#if ($Icinga2.Cache.PerformanceCounter -ne $null) {
# if ($Icinga2.Cache.PerformanceCounter.ContainsKey($counter) -eq $FALSE) {
$RequireSleep = $TRUE;
# }
#}
$obj = New-IcingaPerformanceCounter -Counter $counter -SkipWait $TRUE;
if ($CounterResult.ContainsKey($obj.Name()) -eq $FALSE) {
$CounterResult.Add($obj.Name(), $obj.Value());
}
}
# Above we initialse ever single counter and we only require a sleep once
# in case a new, yet unknown counter was added
if ($RequireSleep) {
Start-Sleep -Milliseconds 500;
# Agreed, this is some sort of code duplication but it wouldn't make
# any sense to create a own function for this. Why are we doing
# this anway?
# Simple: In case we found counters which have yet not been initialised
# we did this above. Now we have waited 500 ms to receive proper
# values from these counters. As the previous generated result
# might have contained counters with 0 results, we will now
# check all counters again to receive the proper values.
# Agreed, might sound like a overhead, but the impact only
# applies to the first call of the module with the counters.
# This 'duplication' however decreased the execution from
# certain modules from 25s to 1s on the first run. Every
# additional run is then beeing executed within 0.x s
# which sounds like a very good performance and solution
$CounterResult = @{};
foreach ($counter in $CounterArray) {
$obj = New-IcingaPerformanceCounter -Counter $counter -SkipWait $TRUE;
if ($CounterResult.ContainsKey($obj.Name()) -eq $FALSE) {
$CounterResult.Add($obj.Name(), $obj.Value());
}
}
}
return $CounterResult;
}

79
lib/core/perfcounter/New-IcingaPerformanceCounterStructure.psm1 Normal file
View file

@ -0,0 +1,79 @@
#
# This function will get handy in case we want to fetch Counters
# which have instances which might be helpful to group by their
# instances name. This will apply to Disk and Network Interface
# outputs for example, as it would be helpful to combine all
# counter results for a specific disk / interface in one
# result for easier working with these informations
#
function New-IcingaPerformanceCounterStructure()
{
param(
[string]$CounterCategory = '',
[hashtable]$PerformanceCounterHash = @{},
[array]$InstanceNameCleanupArray = @()
)
# The storage variables we require to store our data
[array]$AvailableInstances = @();
[hashtable]$StructuredCounterData = @{};
# With this little trick we can fetch all instances we have and get their unique name
$CounterInstances = New-Object System.Diagnostics.PerformanceCounterCategory($CounterCategory);
foreach ($instance in $CounterInstances.GetInstanceNames()) {
# For some counters we require to apply a 'cleanup' for the instance name
# Example Disks: Some disks are stored with the name
# 'HarddiskVolume1'
# To be able to map the volume correctly to disks, we require to remove
# 'HarddiskVolume' so only '1' will remain, which allows us to map the
# volume correctly afterwards
[string]$CleanInstanceName = $instance;
foreach ($cleanup in $InstanceNameCleanupArray) {
$CleanInstanceName = $CleanInstanceName.Replace($cleanup, '');
}
$AvailableInstances += $CleanInstanceName;
}
# Now let the real magic begin.
# At first we will loop all instances of our Performance Counters, which means all
# instances we have found above. We build a new hashtable then to list the instances
# by their individual name and all corresponding counters as children
# This allows us a structured output with all data for each instance
foreach ($instance in $AvailableInstances) {
# First build a hashtable for each instance to add data to later
$StructuredCounterData.Add($instance, @{});
# Now we need to loop all return values from our Performance Counters
foreach ($InterfaceCounter in $PerformanceCounterHash.Keys) {
# As we just looped the parent counter (Instance *), we now need to
# loop the actual counters for each instance
foreach ($interface in $PerformanceCounterHash[$InterfaceCounter]) {
# Finally let's loop through all the results which contain the values
# to build our new, structured hashtable
foreach ($entry in $interface.Keys) {
# Match the counters based on our current parent index
# (the instance name we want to add the values as children).
if ($entry.Contains('(' + $instance + ')')) {
# To ensure we don't transmit the entire counter name,
# we only want to include the name of the actual counter.
# There is no need to return
# \Network Interface(Desktopadapter Intel[R] Gigabit CT)\Bytes Received/sec
# the naming
# Bytes Received/sec
# is enough
[array]$TmpOutput = $entry.Split('\');
[string]$OutputName = $TmpOutput[$TmpOutput.Count - 1];
# Now add the actual value to our parent instance with the
# improved value name, including the sample and counter value data
$StructuredCounterData[$instance].Add($OutputName, $interface[$entry]);
}
}
}
}
}
return $StructuredCounterData;
}

25
lib/core/perfcounter/Show-IcingaPerformanceCounterCategories.psm1 Normal file
View file

@ -0,0 +1,25 @@
#
# This function will load all available Categories of Performance Counters
# from the registry and outputs them. This will ensure we can fetch the real
# english names instead of the localiced ones
#
function Show-IcingaPerformanceCounterCategories()
{
$RegistryData = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009' `
-Name 'counter' | Select-Object -ExpandProperty Counter;
[array]$Counters = @();
# Now lets loop our registry data and fetch only for counter categories
# Ignore everything else and drop the information
foreach ($counter in $RegistryData) {
# First filter out the ID's of the performance counter
if (-Not ($counter -match "^[\d\.]+$") -And [string]::IsNullOrEmpty($counter) -eq $FALSE) {
# Now check if the value we got is a counter category
if ([System.Diagnostics.PerformanceCounterCategory]::Exists($counter) -eq $TRUE) {
$Counters += $counter;
}
}
}
return $Counters;
}

49
lib/core/perfcounter/Show-IcingaPerformanceCounters.psm1 Normal file
View file

@ -0,0 +1,49 @@
#
# Provide the name of a category to fetch all available counters and
# if there are any instances assigned to it
#
function Show-IcingaPerformanceCounters()
{
param ([string]$CounterCategory);
[hashtable]$counters = @{};
try {
# At first create our Performance Counter object for the category we specified
$Category = New-Object System.Diagnostics.PerformanceCounterCategory($CounterCategory);
# Now loop through all keys to find the name of available counters
foreach ($counter in $Category.ReadCategory().Keys) {
[string]$CounterInstanceAddition = '';
# As counters might also have instances (like interfaces, disks, paging file), we should
# try to load them as well
foreach ($instance in $Category.ReadCategory()[$counter].Keys) {
# If we do not match this magic string, we have multiple instances we can access
# to get informations for different disks, volumes and interfaces for example
if ($instance -ne 'systemdiagnosticsperfcounterlibsingleinstance') {
# Re-Write the name we return of the counter to something we can use directly
# within our modules to load data from. A returned counter will look like this
# for example:
# \PhysicalDisk(*)\avg. disk bytes/read
[string]$UsableCounterName = [string]::Format('\{0}(*)\{1}', $CounterCategory, $counter);
if ($counters.ContainsKey($UsableCounterName) -eq $TRUE) {
$counters[$UsableCounterName] += $Category.ReadCategory()[$counter][$instance];
} else {
$counters.Add($UsableCounterName, @( $Category.ReadCategory()[$counter][$instance] ));
}
} else {
# For counters with no instances, we still require to return a re-build Performance Counter
# output, to make later usage in our modules very easy. This can look like this:
# \System\system up time
[string]$UsableCounterName = [string]::Format('\{0}\{1}', $CounterCategory, $counter);
$counters.Add($UsableCounterName, $null);
}
}
};
} catch {
# In case we run into an error, return an error message
$counters.Add('error', $_.Exception.Message);
}
return $counters;
}