SAM Powershell Script Modification

Hi all

I'm using a very useful SAM monitor that uses a powershell script to provide metrics on filecount, folder size etc.

I would like the output on the right hand side (bytes) to match the statistic on the left (gigabytes)....however I'm not sure on the data transformation needed.

I believe the relevant elements of the script are included below - does anyone know if I can use the XToGiga({value}) transformation somehow?

$ContentSize = $Files | Measure-Object -Property Length -Sum | Select-Object -ExpandProperty Sum

Write-Host "Message.FolderSize: [$( $Folder ) on ${Node.Caption}] and all children use $( $ContentSize.ToString("N0") ) gigabytes"
Write-Host "Statistic.FolderSize: $( $ContentSize )"

Find more posts tagged with

sam

powershell scripting

Accepted answers

All comments

bobmarley

$yourvariable = [math]::round($size[$_] /1Gb, 3)

bobmarley

$yourvariable = [math]::round($size[$_] /1Gb, 3)

adam.beedell

I think the one on the left is dynamic, so if there's mb of stuff it's in mb. so you'd want a similar function on the right. Nab someone else's function for sure

KMSigma.SWI

@adam.beedell and @bobmarley are correct. When you output the "statistic" it's shown (on the left) as an automatically rounded format. Anything over 1024 will be converted to K, over 1024 * 1024 will be converted to MB, etc.

If you want it to "display" (as in the Statistic.Message entry, you'll need to math it yourself. One of the best parts about PowerShell (IMHO) is they have the default multiplies as aliases. (Example: 1KB = 1,024, 1MB = 1,048,576, etc.)

1KB
1MB
1GB
1TB
1PB

Returns:

1024
1048576
1073741824
1099511627776
1125899906842624

You can write your own script to do the conversion. These are a few I have saved:

<#
.Synopsis
   Convert a raw number of bytes to a human-redable version
.DESCRIPTION
   Receives a number of bytes and converts it to a human-readable format like 1485 --> 1.45 KB.  Uses the native PowerShell conversion formulas.
.EXAMPLE
   ConvertTo-NamedByte -Value 9959342080

   9.28 GB

   Converts 9.9 billion bytes to the proper GB size using default rounding (to 2 places) 
.EXAMPLE
   ConvertTo-NamedByte -Value 9959342 -RoundTo 5

   9.49797 MB
   Converts about 10 MB to actual number, but rounds to 5 places.
.INPUTS
   N/A
.OUTPUTS
   Strings containing the converted values
.NOTES
   Written to help speed up display values
.COMPONENT
   N/A
.ROLE
   N/A
.FUNCTIONALITY
   Converts to a string.
#>
function ConvertTo-NamedByte
{
    [CmdletBinding(DefaultParameterSetName='Default', 
                  SupportsShouldProcess=$true, 
                  PositionalBinding=$false,
                  ConfirmImpact='Low')]
    [Alias()]
    [OutputType([String])]
    Param
    (
        # Bytes value
        [Parameter(Mandatory=$true, 
                   ValueFromPipeline=$true,
                   ValueFromPipelineByPropertyName=$true, 
                   ValueFromRemainingArguments=$false, 
                   Position=0,
                   ParameterSetName='Default')]
        [ValidateNotNull()]
        [ValidateNotNullOrEmpty()]
        [Alias("Bytes")] 
        [int64[]]$Value,

        # Round to Decimals (defautls to 2)
        [Parameter(ParameterSetName='Default')]
        [ValidateRange(0,[int]::MaxValue)]
        [int]$RoundTo = 2
    )

    Begin {
        # Store the ToString conversion
        $DecimalOutput = "." + ( "0" * $RoundTo )
        Write-Verbose -Message "DecimanOutput: $DecimalOutput"
    }
    Process
    {
        ForEach ( $V in $Value ) {
            if ($pscmdlet.ShouldProcess("Convert $($V)", "to bytes with $RoundTo decimal places")) {
                if ( $V -ge 1PB ) {
                    "$( ( [math]::Round($V / 1PB, $RoundTo) ).ToString( $DecimalOutput ) ) PB"
                }
                elseif ( $V -gt 1TB ) {
                    "$( ( [math]::Round($V / 1TB, $RoundTo) ).ToString( $DecimalOutput ) ) TB"
                }
                elseif ( $V -gt 1GB ) {
                    "$( ( [math]::Round($V / 1GB, $RoundTo) ).ToString( $DecimalOutput ) ) GB"
                }
                elseif ( $V -gt 1MB ) {
                    "$( ( [math]::Round($V / 1MB, $RoundTo) ).ToString( $DecimalOutput ) ) MB"
                }
                elseif ( $V -gt 1KB ) {
                    "$( ( [math]::Round($V / 1KB, $RoundTo) ).ToString( $DecimalOutput ) ) KB"
                }
                else {
                    "$( $V ) B"
                }
            }
        }
    }
    End {
        # Nothing to see here
    }
}

<# Some Examples:
ConvertTo-NamedByte -Value 9959342080
# 9.28 GB
ConvertTo-NamedByte -Value 9959342 -RoundTo 4
# 9.4980 MB
9959342080, 9959342 | ConvertTo-NamedByte
9.28 GB
9.50 MB
#>

<#
.Synopsis
   Convert large numbers to byte formatting
.DESCRIPTION
   Convert numbers, representing bytes, back to the O365 format.
.EXAMPLE
   PS C:\> ConvertTo-ByteQuantitySize -Bytes 1000000000000
   931.32 GB (1,000,000,000,000 bytes)
.EXAMPLE
   PS C:\> 10000 | ConvertTo-ByteQuantitySize
   9.77 KB (10,000 bytes)
.INPUTS
   Integers between 0 and 1 exabyte - 1 byte
.OUTPUTS
   Strings in '#.## ?B ( #,### bytes )' format
.NOTES
   Created by Kevin M. Sparenberg (http://blog.kmsigma.com)
#>
function ConvertTo-ByteQuantitySize
{
    [CmdletBinding()]
    [Alias()]
    [OutputType([string])]
    Param
    (
        # big integer of the size (in bytes)
        [Parameter(Mandatory=$true, 
                   ValueFromPipeline=$true,
                   ValueFromPipelineByPropertyName=$true, 
                   ValueFromRemainingArguments=$false, 
                   Position=0)]
        [ValidateNotNull()]
        [ValidateNotNullOrEmpty()]
        [ValidateRange(0, ( 1024 * 1PB ) - 1)]
        [Alias("B")] 
        [bigint[]]$Bytes

    )

    Begin
    {
        # Nothing to see here
        $Ranges = @()
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Bytes"; ShortQuantifier = "B"; MinValue = [bigint]( 0 ); MaxValue = [bigint]( 1KB ); Divisor = [bigint]( 1 )}
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Kilobytes"; ShortQuantifier = "KB"; MinValue = [bigint]( 1KB ); MaxValue = [bigint]( 1MB ); Divisor = [bigint]( 1KB ) }
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Megabytes"; ShortQuantifier = "MB"; MinValue = [bigint]( 1MB ); MaxValue = [bigint]( 1GB ); Divisor = [bigint]( 1MB ) }
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Gigabytes"; ShortQuantifier = "GB"; MinValue = [bigint]( 1GB ); MaxValue = [bigint]( 1TB ); Divisor = [bigint]( 1GB ) }
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Terabytes"; ShortQuantifier = "TB"; MinValue = [bigint]( 1TB ); MaxValue = [bigint]( 1PB ); Divisor = [bigint]( 1TB ) }
        $Ranges += New-Object -TypeName PSObject -Property @{ Quantifier = "Petabytes"; ShortQuantifier = "PB"; MinValue = [bigint]( 1PB ); MaxValue = [bigint]( 1PB * 1024 ); Divisor = [bigint]( 1PB ) }
    }
    Process
    {
        ForEach ( $b in $Bytes )
        {
            ForEach ( $Range in $Ranges )
            {
                if ( ( $b -ge $Range.MinValue ) -and ( $b -lt $Range.MaxValue ) )
                {
                    $ByteString = $b.ToString("#,###")
                    "$( [Math]::Round( ( [double]( $b ) ) / $( [double]( $Range.Divisor ) ), 2 ) ) $( $Range.ShortQuantifier ) ($ByteString bytes)"
                }
            }
        }
    }
    End
    {
        # Nothing to see here
    }
}