PSLogParser

0.0.2

PSLogParser.psm1

# Module created by Microsoft.PowerShell.Crescendo
class PowerShellCustomFunctionAttribute : System.Attribute {
    [bool]$RequiresElevation
    [string]$Source
    PowerShellCustomFunctionAttribute() { $this.RequiresElevation = $false; $this.Source = "Microsoft.PowerShell.Crescendo" }
    PowerShellCustomFunctionAttribute([bool]$rElevation) {
        $this.RequiresElevation = $rElevation
        $this.Source = "Microsoft.PowerShell.Crescendo"
    }
}



function Invoke-PSLogParser {
    [PowerShellCustomFunctionAttribute(RequiresElevation = $False)]
    [CmdletBinding()]

    param(
        [Parameter()]
        [ValidateSet("IISW3C", "NCSA", "IIS", "IISODBC", "BIN", "IISMSID", "HTTPERR", "URLSCAN", "CSV", "TSV", "W3C", "XML", "EVT", "ETW", "NETMON", "REG", "ADS", "TEXTLINE", "TEXTWORD", "FS", "COM")]
        [string]$InputLogFileType,
        [Parameter()]
        [ValidateSet("CSV", "TSV", "XML", "DATAGRID", "CHART", "SYSLOG", "NEUROVIEW", "NAT", "W3C", "IIS", "SQL", "TPL", "NULL")]
        [string]$OutputLogFileType,
        [Parameter(Mandatory)]
        [string]$SQLquery,
        [Parameter()]
        [switch]$WhatIf
    )

    BEGIN {
        $__PARAMETERMAP = @{
            InputLogFileType  = @{
                OriginalName      = '-i:'
                OriginalPosition  = '0'
                Position          = '2147483647'
                ParameterType     = 'string'
                ApplyToExecutable = $False
                NoGap             = $False
            }
            OutputLogFileType = @{
                OriginalName      = '-o:'
                OriginalPosition  = '1'
                Position          = '2147483647'
                ParameterType     = 'string'
                ApplyToExecutable = $False
                NoGap             = $False
            }
            SQLquery          = @{
                OriginalName      = ''
                OriginalPosition  = '2'
                Position          = '2147483647'
                ParameterType     = 'string'
                ApplyToExecutable = $False
                NoGap             = $False
            }
            WhatIf            = @{
                OriginalName      = '-queryInfo'
                OriginalPosition  = '3'
                Position          = '2147483647'
                ParameterType     = 'switch'
                ApplyToExecutable = $False
                NoGap             = $False
            }
        }

        $__outputHandlers = @{ Default = @{ StreamOutput = $true; Handler = { $input } } }
    }

    PROCESS {
        $__boundParameters = $PSBoundParameters
        $__defaultValueParameters = $PSCmdlet.MyInvocation.MyCommand.Parameters.Values.Where({ $_.Attributes.Where({ $_.TypeId.Name -eq "PSDefaultValueAttribute" }) }).Name
        $__defaultValueParameters.Where({ !$__boundParameters["$_"] }).ForEach({ $__boundParameters["$_"] = Get-Variable -value $_ })
        $__commandArgs = @()
        $MyInvocation.MyCommand.Parameters.Values.Where({ $_.SwitchParameter -and $_.Name -notmatch "Debug|Whatif|Confirm|Verbose" -and ! $__boundParameters[$_.Name] }).ForEach({ $__boundParameters[$_.Name] = [switch]::new($false) })
        if ($__boundParameters["Debug"]) { Wait-Debugger }
        foreach ($paramName in $__boundParameters.Keys |
            Where-Object { !$__PARAMETERMAP[$_].ApplyToExecutable } |
            Sort-Object { $__PARAMETERMAP[$_].OriginalPosition }) {
            $value = $__boundParameters[$paramName]
            $param = $__PARAMETERMAP[$paramName]
            if ($param) {
                if ($value -is [switch]) {
                    if ($value.IsPresent) {
                        if ($param.OriginalName) { $__commandArgs += $param.OriginalName }
                    }
                    elseif ($param.DefaultMissingValue) { $__commandArgs += $param.DefaultMissingValue }
                }
                elseif ( $param.NoGap ) {
                    $pFmt = "{0}{1}"
                    if ($value -match "\s") { $pFmt = "{0}""{1}""" }
                    $__commandArgs += $pFmt -f $param.OriginalName, $value
                }
                else {
                    if ($param.OriginalName) { $__commandArgs += $param.OriginalName }
                    $__commandArgs += $value | ForEach-Object { $_ }
                }
            }
        }
        $__commandArgs = $__commandArgs | Where-Object { $_ -ne $null }
        if ($__boundParameters["Debug"]) { Wait-Debugger }
        if ( $__boundParameters["Verbose"]) {
            Write-Verbose -Verbose -Message .\LogParser.exe
            $__commandArgs | Write-Verbose -Verbose
        }
        $__handlerInfo = $__outputHandlers[$PSCmdlet.ParameterSetName]
        if (! $__handlerInfo ) {
            $__handlerInfo = $__outputHandlers["Default"] # Guaranteed to be present
        }
        $__handler = $__handlerInfo.Handler
        if ( $PSCmdlet.ShouldProcess(".\LogParser.exe $__commandArgs")) {
            # check for the application and throw if it cannot be found
            if ( -not (Get-Command -ErrorAction Ignore ".\LogParser.exe")) {
                throw "Cannot find executable '.\LogParser.exe'"
            }
            if ( $__handlerInfo.StreamOutput ) {
                & ".\LogParser.exe" $__commandArgs | & $__handler
            }
            else {
                $result = & ".\LogParser.exe" $__commandArgs
                & $__handler $result
            }
        }
    } # end PROCESS

    <#
 
 
.DESCRIPTION
Reads a log file and outputs to a given format specified
 
.PARAMETER InputLogFileType
Set the type of log file you are about to process
 
 
.PARAMETER OutputLogFileType
Set the output filetype of this log to convert to
 
 
.PARAMETER SQLquery
Mandatory parameter in order to make this module work keep it simple if unsure like "Select * From C:\logfile.log"
 
 
.PARAMETER WhatIf
Shows what would be run if you were to run the query
 
 
 
#>
}