{"id":6336,"date":"2018-12-28T12:28:17","date_gmt":"2018-12-28T17:28:17","guid":{"rendered":"https:\/\/jdhitsolutions.com\/blog\/?p=6336"},"modified":"2019-01-02T09:09:02","modified_gmt":"2019-01-02T14:09:02","slug":"building-a-powershell-process-memory-tool","status":"publish","type":"post","link":"https:\/\/jdhitsolutions.com\/blog\/powershell\/6336\/building-a-powershell-process-memory-tool\/","title":{"rendered":"Building a PowerShell Process Memory Tool"},"content":{"rendered":"

This week I've been testing out a new browser, Brave<\/a>, as a possible replacement for Firefox. One of the reasons I switched to Firefox from Chrome was performance and better resource utilization. Brave may now be a better choice, but that's not what this article is about. In order to assess resource utilization I turned to the Get-Process<\/a> PowerShell cmdlet. Because I found myself needing to get some very specific results, I decided to write a PowerShell function to simplify the process. This is why you<\/em> should be learning and using PowerShell, to build your own tools to solve your<\/em> business needs. Here is some of the story on my development process.<\/p>\n

<\/p>\n

Start with the Basics<\/h1>\n

I first started with a core PowerShell expression to display process information, using the Workingset property.<\/p>\n

Get-Process brave | Measure-Object Workingset -sum -average | \nSelect-object Count,Sum,Average\n<\/pre>\n
Substitute in any process you want like chrome to see similar results. This simple expression gets all the brave processes and pipes them to Measure-Object<\/a> which calculates the sum and average of the workingset property. It would be helpful to see the process name in the output especially because I intend to do comparisons with Firefox. If I do this:<\/p>\n
Get-Process brave,firefox | Measure-Object Workingset -sum -average | \nSelect-object Count,Sum,Average\n<\/pre>\n
I get the sum for both browsers. No. I would need to run Get-Process and Measure-Object for each process. One way would be to use ForEach-Object<\/a>.<\/p>\n
\"brave\",\"firefox\" | foreach-object {\nGet-Process -name $_ -PipelineVariable pv | \nMeasure-Object Workingset -sum -average | \nSelect-object @{Name=\"Name\";Expression = {$pv.name}},\nCount,Sum,Average\n}\n<\/pre>\n
This is better. I'm using the common PipelineVariable parameter to retrieve the process name. Measure-Object's output doesn't include the process name from Get-Process so in order for Select-Object<\/a> to work I need a way to access something from earlier in the pipeline. That's what PipelineVariable achieves.<\/p>\n
\"Getting<\/a><\/p>\n
Formatting Values<\/h1>\n
I don't know about you but I can't readily convert all those bytes into something more meaningful. But PowerShell can.<\/p>\n
\"brave\",\"firefox\" | foreach-object {\nGet-Process -name $_ -PipelineVariable pv | \nMeasure-Object Workingset -sum -average | \nSelect-object @{Name=\"Name\";Expression = {$pv.name}},\nCount,\n@{Name=\"SumMB\";Expression = {[math]::round($_.Sum\/1MB,2)}},\n@{Name=\"AvgMB\";Expression = {[math]::round($_.Average\/1MB,2)}}\n}\n<\/pre>\n
I now have code that generates the friendly result I need.<\/p>\n
\"PowerShell<\/a><\/p>\n
But I need to make this flexible and re-usable. This is where functions come into play. I can quickly turn this into a function.<\/p>\n
Function Get-MyProcess {\n[cmdletbinding()]\nParam([string[]]$Name)\n\n$Name | foreach-object {\nGet-Process -name $_ -PipelineVariable pv | \nMeasure-Object Workingset -sum -average | \nSelect-object @{Name=\"Name\";Expression = {$pv.name}},\nCount,\n@{Name=\"SumMB\";Expression = {[math]::round($_.Sum\/1MB,2)}},\n@{Name=\"AvgMB\";Expression = {[math]::round($_.Average\/1MB,2)}}\n}\n\n}\n<\/pre>\n
And it works.<\/p>\n
\"Results<\/a><\/p>\n
Scaling Out<\/h1>\n
At this point I could<\/em> consider this complete. However, when I write PowerShell functions, especially something is getting values or data, I typically want to be able to have it work with remote computers. My initial thought was that because Get-Process has a -Computername parameter, all I had to do was add it to my function and pass it along in the code. The potential downside to this approach is that when you connect to a remote computer in this way, you are connecting over legacy remoting connections. I'm trying to avoid using legacy connections where possible so that means I need to take advantage of PowerShell remoting.\u00a0 One solution would be to wrap my Get-Process command inside an Invoke-Command expression.<\/p>\n
Function Get-MyProcess {\n[cmdletbinding()]\nParam([string[]]$Name,[string]$Computername = $env:computername)\n\nInvoke-Command -ScriptBlock {\n$using:Name | foreach-object {\nGet-Process -name $_ -PipelineVariable pv | \nMeasure-Object Workingset -sum -average | \nSelect-object @{Name=\"Name\";Expression = {$pv.name}},\nCount,\n@{Name=\"SumMB\";Expression = {[math]::round($_.Sum\/1MB,2)}},\n@{Name=\"AvgMB\";Expression = {[math]::round($_.Average\/1MB,2)}}\n}\n} -ComputerName $computername\n}\n<\/pre>\n
This is getting closer to a mature, PowerShell function.<\/p>\n
\"Getting<\/a><\/p>\n
Functions Don't Format<\/h1>\n
As you can see, this function doesn't include any error handling. And since I never need to see the RunspaceID property I would always have to wrap my function in another PowerShell expression to remove it. It would be nicer if the function wrote an object to the pipeline with just values I wanted to see. The other potential drawback is that my sum and average values are formatted in MB. I have made an assumption that limits the flexibility of this function. I was initially lazy. The better approach is to write an object to the pipeline with raw, unformatted data.<\/p>\n
As I revised the function, this became the core of the scriptblock:<\/p>\n
foreach ($item in $ProcessName) {\n    Get-Process -Name $item -PipelineVariable pv -OutVariable ov |\n        Measure-Object -Property WorkingSet -Sum -Average |\n        Select-Object -Property @{Name = \"Name\"; Expression = {$pv.name}},\n    Count, \n    @{Name = \"Threads\"; Expression = {$ov.threads.count}},\n    Average, Sum,\n    @{Name = \"Computername\"; Expression = {$env:computername}} \n}\n<\/pre>\n
The output values were now back to bytes. But you know, I really would like to see them formatted as MB by default. PowerShell can do that and if fact does that all the time. When you run Get-Process the default display is formatted for you. What you see is not the raw value of the underlying process objects.\u00a0 PowerShell is using a format directive. You can too.<\/p>\n
Format Data<\/h1>\n
First, you need to give your output object a type name. I could have built a function using a PowerShell class. But it is just as easy to insert a type name.<\/p>\n
Invoke-Command @PSBoundParameters | Select-Object -Property * -ExcludeProperty RunspaceID,PS* |\nForEach-Object {\n    #insert a custom type name for the format directive\n    $_.psobject.typenames.insert(0, \"myProcessMemory\") | Out-Null\n    $_\n}\n<\/pre>\n
Now the tricky part. Format directives are special XML files saved with a .ps1xml file. One of the things I can do is define a custom heading and value.<\/p>\n
<TableColumnItem>\n    <ScriptBlock>[math]::Round($_.average\/1MB,4)<\/ScriptBlock>\n<\/TableColumnItem>\n<\/pre>\n
The default output uses the formatting directives but I can still use the underlying actual property names.<\/p>\n
\"Using<\/a><\/p>\n
By the way, don't read too much into these results as Firefox has a lot of extensions and Brave has several open tabs.<\/p>\n
Instead of creating a separate .ps1xml file, I included the contents as a here string in my script file with my function and create a temporary file which is then imported using Update-FormatData<\/a>. The complete file is on Github<\/a>.<\/p>\n