# encoding: ascii
# api: powershell
# title: Logger.psm1
# description: The simplest logger. In your script just import-module Logger and debug, verbose, warnings and errors are logged to file.
# version: 0.5
# type: module
# author: Joel Bennett
# license: CC0
# function: Get-RelativePath
# x-poshcode-id: 1825
# x-derived-from-id: 1858
# x-archived: 2017-02-26T04:34:54
# x-published: 2011-05-08T14:18:00
#
# This is a simple wrapper around NLog4 which (by default) causes Write-Verbose, Write-Warning, Write-Debug, and Write-Error to log their output when called from (any) script. By default it logs to file, but it can log to the event log, console, .net trace or debug, udp, xml, and even GrowlForWindows by simply using the Get-Logger function to configure new loggers.
# There are a few extra helper methods in here, including Push-Context/Pop-Context (which you can call in your functions to enable stack tracing), and still more to come.
# New in this release:
# 0.5 – Port to NLog from Log4Net ( http://nlog-project.org )
# Include support for Growl plugin for NLog, but left out the rotating log files stuff (I’ll get to that later).
# http://ryanfarley.com/blog/archive/2010/05/06/announcing-the-growl-for-windows-target-for-nlog.aspx
# Note: I’m not (yet) going to say NLog is better than log4net, but the project looks active, and there’s a Growl plugin, and MSMQ support in the core.
#
<#
Name : Universal NLog Logging Module (NLog.psm1)
Version : 0.5
Author : Joel Bennett (MVP)
Site : http://www.HuddledMasses.org/
Version History:
0.5 - Port to NLog from Log4Net ( http://nlog-project.org )
Include support for Growl plugin for NLog, but left out the rotating log files stuff (I'll get to that later).
http://ryanfarley.com/blog/archive/2010/05/06/announcing-the-growl-for-windows-target-for-nlog.aspx
0.4 - Bugfix, Viewer and Documentation release.
Fixed a few typo-bugs
Added documentation (man page) comments for Get-Logger.
Changed a few parameter names (sorry) to make the default parameters more unique (so you have to type less on the command-line)
Changed the default logger to use the logger module's folder as a backup
(Some people might not have the Profile path -- this module could be installed anywhere and loaded by file name)
Fixed up the xml output with a nice stylesheet http`://poshcode.org/1750 that formats and makes the page refresh.
0.3 - Cleanupable release.
Added Udp, Email, Xml and RollingXml, as well as a "Chainsaw":http`://logging.apache.org/log4j/docs/chainsaw.html logger based on "Szymon Kobalczyk's configuration":http`://geekswithblogs.net/kobush/archive/2005/07/15/46627.aspx.
Note: there is a "KNOWN BUG with Log4Net UDP":http`://odalet.wordpress.com/2007/01/13/log4net-ip-parsing-bug-when-used-with-framework-net-20/ which can be patched, but hasn't been released.
Added a Close-Logger method to clean up the Xml logger
NOTE: the Rolling XML Logger produces invalid XML, and the XML logger only produces valid xml after it's been closed...
I did contribute an "XSLT stylesheet for Log4Net":http`://poshcode.org/1746 which you could use as well
0.2 - Configless release.
Now configures with inline XML, and supports switches to create "reasonable" default loggers
Changed all the functions to Write-*Log so they don't overwrite the cmdlets
Added -Logger parameter to take the name of the logger to use (it must be created beforehand via Get-Logger)
Created aliases for Write-* to override the cmdlets -- these are easy for users to remove without breaking the module
** NEED to write some docs, but basically, this is stupid simple to use, just:
Import-Module Logger
Write-Verbose "This message will be saved in your profile folder in a file named PowerShellLogger.log (by default)"
To change the defaults for your system, edit the last line in the module!!
0.1 - Initial release. http`://poshcode.org/1744 (Required config: http`://poshcode.org/1743)
Uses NLog 2.0 : http://nlog-project.org
Documentation : http://nlog-project.org/documentation.html
NOTES:
By default, this overwrites the Write-* cmdlets for Error, Warning, Debug, Verbose, and even Host.
This means that you may end up logging a lot of stuff you didn't intend to log (ie: verbose output from other scripts)
To avoid this behavior, remove the aliases after importing it
Import-Module Logger; Remove-Item Alias:Write-*
Write-Warning "This is your warning"
Write-Debug "You should know that..."
Write-Verbose "Everything would be logged, otherwise"
***** NOTE: IT ONLY OVERRIDES THE DEFAULTS FOR SCRIPTS *****
It currently has no effect on error/verbose/warning that is logged from cmdlets.
#>
Add-Type -Path $PSScriptRoot\NLog.dll
function Get-RelativePath {
<#
.SYNOPSIS
Get a path to a file (or folder) relative to another folder
.DESCRIPTION
Converts the FilePath to a relative path rooted in the specified Folder
.PARAMETER Folder
The folder to build a relative path from
.PARAMETER FilePath
The File (or folder) to build a relative path TO
.PARAMETER Resolve
If true, the file and folder paths must exist
.Example
Get-RelativePath ~\Documents\WindowsPowerShell\Logs\ ~\Documents\WindowsPowershell\Modules\Logger\log4net.xslt
..\Modules\Logger\log4net.xslt
Returns a path to log4net.xslt relative to the Logs folder
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, Position=0)]
[string]$Folder
,
[Parameter(Mandatory=$true, Position=1, ValueFromPipelineByPropertyName=$true)]
[Alias("FullName")]
[string]$FilePath
,
[switch]$Resolve
)
process {
$from = $Folder = split-path $Folder -NoQualifier -Resolve:$Resolve
$to = $filePath = split-path $filePath -NoQualifier -Resolve:$Resolve
while($from -and $to -and ($from -ne $to)) {
if($from.Length -gt $to.Length) {
$from = split-path $from
} else {
$to = split-path $to
}
}
$filepath = $filepath -replace "^"+[regex]::Escape($to)+"\\"
$from = $Folder
while($from -and $to -and $from -gt $to ) {
$from = split-path $from
$filepath = join-path ".." $filepath
}
Write-Output $filepath
}
}
function Get-Logger {
<#
.SYNOPSIS
Get an existing Logger by name, or create a new logger
.DESCRIPTION
Returns a logger matching the name (wildcards allowed) provided.
If the logger already exists, it is returned with it's settings as-is, unless the -Force switch is specified, in which case the new settings are used
If only one logger matches the name, that logger becomes the new default logger.
.PARAMETER Name
The name of the logger to find or create. If no name is specified, all existing loggers are returned.
.PARAMETER Level
The level at which to log in this new logger. Defaults to "DEBUG"
Possible levels are as follows (each level includes all levels above it):
FATAL
ERROR
WARN (aka WARNING)
INFO (aka VERBOSE, HOST)
DEBUG
.PARAMETER MessagePattern
The pattern for loggers which use patterns (mostly the file loggers). Defaults to:
' ${longdate} ${level:uppercase=true} ${logger} [${ndc}] [${ndc}] - ${message}${newline}'
For a complete list of possible pattern names, see:
http://nlog-project.org/layoutrenderers.html
.PARAMETER Growl
Outputs log messages to growl
For reference see:
http://ryanfarley.com/blog/archive/2010/05/06/announcing-the-growl-for-windows-target-for-nlog.aspx
.PARAMETER Folder
The folder where log files are kept. Defaults to your Documents\WindowsPowerShell folder.
NOTE: if the specified folder does not exist, the fallback is your Documents\WindowsPowerShell folder,
but if that doesn't exist, the folder where this file is stored is used.
.PARAMETER EmailTo
An email address to send WARNING or above messages to. REQUIRES that your $PSEmailServer variable be set
.PARAMETER Console
Creates a colored console logger
.PARAMETER EventLog
Creates an EventLog logger
.PARAMETER TraceLog
Creates a .Net Trace logger
.PARAMETER DebugLog
Creates a .Net Debug logger
.PARAMETER FileLog
Creates a file logger. Note the LogLock parameter!
.PARAMETER RollingFileLog
Creates a rolling file logger with a max size of 250KB. Note the LogLock parameter!
.PARAMETER XmlLog
Creates an Xml-formatted file logger. Note the LogLock parameter!
Note: the XmlLog will output an XML Header and will add a footer when the logger is closed.
This results in a log file which is readable in xml viewers like IE, particularly if you have a copy of the XSLT stylesheet for Log4Net (http://poshcode.org/1750) named log4net.xslt in the same folder with the log file.
WARNING: Because of this, it does not APPEND to the file, but overwrites it each time you create the logger.
.PARAMETER RollingXmlLog
Creates a rolling file Xml logger with a max size of 500KB. Note the LogLock parameter!
Note: the rolling xml logger cannot create "valid" xml because it appends to the end of the file (and therefore can't guarantee the file is well-formed XML).
In order to get a valid Xml file, you can use a "*View.xml" file with contents like this (which this script will create):
<?xml version="1.0" ?>
<?xml-stylesheet type="text/xsl" href="log4net.xslt"?>
<!DOCTYPE events [<!ENTITY data SYSTEM "PowerShellLogger.xml">]>
<log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2">
&data;
</log4net:events>
.PARAMETER LogLock
Determines the type of file locking used (defaults to SHARED):
SHARED is the "MinimalLocking" model which opens the file once for each AcquireLock/ReleaseLock cycle, thus holding the lock for the minimal amount of time. This method of locking is considerably slower than...
EXCLUSIVE is the "ExclusiveLocking" model which opens the file once for writing and holds it open until the logger is closed, maintaining an exclusive lock on the file the whole time..
.PARAMETER UdpSend
Creates an UdpAppender which sends messages to the localmachine port 8080
We'll probably tweak this in a future release, but for now if you need to change that you need to edit the script
.PARAMETER ChainsawSend
Like UdpSend, creates an UdpAppender which sends messages to the localmachine port 8080.
This logger uses the log4j xml formatter which is somewhat different than the default, and uses their namespace.
.PARAMETER Force
Force resetting the logger switches even if the logger already exists
#>
param(
[Parameter(Mandatory=$false, Position=0)]
[string]$Name = "*"
,
[Parameter(Mandatory=$false)]
# Actual Values: Trace, Debug, Info, Warn, Error, Fatal
[ValidateSet("Verbose","Trace","Debug","Info","Host","Warn","Warning","Error","Fatal")]
[string]$Level = "Trace"
,
[Parameter(Mandatory=$false)]
#" %date %-5level %logger [%property{NDC}] - %message%newline"
$MessagePattern = ' ${longdate} ${level:uppercase=true} ${logger} - ${message}${newline}'
,
[Parameter(Mandatory=$false)]
[string]$Folder = $(Split-Path $Profile.CurrentUserAllHosts)
, [String]$EmailTo
, [Switch]$Force
, [Switch]$ConsoleLog
, [Switch]$EventLog
, [Switch]$TraceLog
, [Switch]$DebugLog
, [Switch]$FileLog
#, [Switch]$RollingFileLog
, [Switch]$XmlLog
#, [Switch]$RollingXmlLog
, [Switch]$UdpSend
, [Switch]$ChainsawSend
, [Switch]$Growl
# ,
# [Parameter(Mandatory=$false, Position=99)]
# [ValidateSet("Shared","Exclusive")]
# [String]$LogLock = "Shared"
)
## Make sure the folder exists
if(!(Test-Path $Folder)) {
$Folder = Split-Path $Profile.CurrentUserAllHosts
if(!(Test-Path $Folder)) {
$Folder = $PSScriptRoot
}
}
$Script:NLogLoggersCollection | Where-Object { $_.Name -Like $Name } | Tee -var LoggerOutputBuffer
if((!(test-path Variable:LoggerOutputBuffer) -or $Force) -and !$Name.Contains('*')) {
if($Level -eq "VERBOSE") { $Level = "Trace" }
if($Level -eq "HOST") { $Level = "Info" }
if($Level -eq "WARNING") { $Level = "Warn" }
$Targets = @()
if(test-path Variable:Email) {
if(!$PSEmailServer) { throw "You need to specify your SMTP mail server by setting the global $PSEmailServer variable" }
$Targets += "Mail"
$Null,$Domain = $email -split "@",2
} else { $Domain = "no.com" }
# if($LogLock -eq "Shared") {
# $LockMode = "MinimalLock"
# } else {
# $LockMode = "ExclusiveLock"
# }
$xslt = ""
if(Test-Path $PSScriptRoot\log4net.xslt) {
$xslt = @"
<?xml-stylesheet type="text/xsl" href="$(Get-RelativePath $Folder $PSScriptRoot\NLog.xslt)"?>
"@
}
Set-Content "${Folder}\${Name}View.Xml" @"
<?xml version="1.0" ?>
$xslt
<!DOCTYPE events [<!ENTITY data SYSTEM "$Name.xml">]>
<events version="1.2" xmlns:log4net="http`://logging.apache.org/log4net/schemas/log4net-events-1.2">
<logname>$Name</logname>
&data;
</events>
"@
if($EventLog) { $Targets += "EventLog" }
if($TraceLog) { $Targets += "Trace" }
if($DebugLog) { $Targets += "Debug" }
if($FileLog) { $Targets += "File" }
# if($RollingFileLog) { $Targets += "<appender-ref ref=""RollingFileAppender"" />`n" }
if($UdpSend) { $Targets += "Udp" }
if($Growl) { $Targets += "Growl" }
if($ChainsawSend) { $Targets += "Chainsaw" }
if($XmlLog) { $Targets += "Xml" }
# if($RollingXmlLog) { $Targets += "<appender-ref ref=""RollingXmlAppender"" />`n"
if($VerbosePreference -gt "SilentlyContinue") { "Created XML viewer for you at: ${Folder}\${Name}View.Xml" }
$xslt = $xslt -replace "<","<" -replace ">",">" -replace '"',"'"
if($ConsoleLog -or ($Targets.Count -eq 0)) { $Targets += "Console" }
$extensions = ""
if($Growl -and (Test-Path $PSScriptRoot\NLog.Targets.GrowlNotify.dll)){
$extensions = @"
<extensions>
<add assembly="NLog.Targets.GrowlNotify" />
</extensions>
"@ }
$OFS = ","
[xml]$config = @"
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
$extensions
<targets>
<target name="Console" xsi:type="ColoredConsole" layout="$MessagePattern"/>
<target name="File" xsi:type="File" fileName="$Folder\$Name.log" layout="$MessagePattern"/>
<target name="Xml" xsi:type="File" fileName="$Folder\$Name.xml" layout="`${log4jxmlevent}"/>
<target name="EventLog" xsi:type="EventLog" log="Application" source="$Name" layout="$MessagePattern"/>
<target name="Trace" xsi:type="Trace" layout="$MessagePattern"/>
<target name="Debug" xsi:type="Debugger" layout="$MessagePattern"/>
<target name="Udp" xsi:type="Network" address="udp://localhost:8080" layout="$MessagePattern"/>
<target name="Chainsaw" xsi:type="Chainsaw" address="udp://localhost:8080" />
$(if($Growl){ '<target name="Growl" xsi:type="GrowlNotify" layout="$MessagePattern"/>' })
<target name="Mail" xsi:type="FilteringWrapper" condition="level > LogLevel.Debug or contains(message,'email')" >
<target xsi:type="Mail" addNewLines="True" smtpServer="$PSEmailServer" layout="$MessagePattern"
from="PoshLogger@$Domain" to="$EmailTo" subject="PowerShell Logger Message" />
</target>
</targets>
<rules>
<logger name="$Name" minlevel="$Level" writeTo="$Targets"/>
</rules>
</nlog>
"@
$config.Save("${PSScriptRoot}\NLog.config")
[NLog.LogManager]::Configuration = New-Object 'NLog.Config.XmlLoggingConfiguration' $config.nlog, $PSScriptRoot\NLog.config
$Script:NLogLoggersCollection += $Script:Logger = [NLog.LogManager]::GetLogger($Name)
write-output $Script:Logger
}
elseif($NLogLoggersCollection.Count -eq 1) {
$script:Logger = $NLogLoggersCollection[0]
write-output $Script:Logger
}
}
function Set-Logger {
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[NLog.Logger]$Logger
)
$script:Logger = $Logger
}
function Push-LogContext {
param(
[Parameter(Mandatory=$true)]
[string]$Name
)
[NLog.Contexts.NestedDiagnosticsContext]::Push($Name)
}
function Pop-LogContext {
[NLog.Contexts.NestedDiagnosticsContext]::Pop()
}
function Write-DebugLog {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
[Alias('Msg')]
[AllowEmptyString()]
[System.String]
${Message}
,
[Parameter(Mandatory=$false, Position=99)]
${Logger})
begin
{
try {
if($PSBoundParameters.ContainsKey("Logger")) {
if($Logger -is [log4net.Core.LogImpl]) { Set-Logger $Logger } else { $script:Logger = Get-Logger "$Logger" }
$null = $PSBoundParameters.Remove("Logger")
}
$outBuffer = $null
if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
{
$PSBoundParameters['OutBuffer'] = 1
}
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Write-Debug', [System.Management.Automation.CommandTypes]::Cmdlet)
$scriptCmd = {& $wrappedCmd @PSBoundParameters }
$steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
$steppablePipeline.Begin($PSCmdlet)
} catch {
throw
}
}
process
{
try {
$script:logger.Debug($Message) #Write-Debug
$steppablePipeline.Process($_)
} catch {
throw
}
}
end
{
try {
$steppablePipeline.End()
} catch {
throw
}
}
<#
.ForwardHelpTargetName Write-Debug
.ForwardHelpCategory Cmdlet
#>
}
function Write-VerboseLog {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
[Alias('Msg')]
[AllowEmptyString()]
[System.String]
${Message}
,
[Parameter(Mandatory=$false, Position=99)]
${Logger})
begin
{
try {
if($PSBoundParameters.ContainsKey("Logger")) {
if($Logger -is [log4net.Core.LogImpl]) { Set-Logger $Logger } else { $script:Logger = Get-Logger "$Logger" }
$null = $PSBoundParameters.Remove("Logger")
}
$outBuffer = $null
if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
{
$PSBoundParameters['OutBuffer'] = 1
}
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Write-Verbose', [System.Management.Automation.CommandTypes]::Cmdlet)
$scriptCmd = {& $wrappedCmd @PSBoundParameters }
$steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
$steppablePipeline.Begin($PSCmdlet)
} catch {
throw
}
}
process
{
try {
$script:logger.Trace($Message)
$steppablePipeline.Process($_)
} catch {
throw
}
}
end
{
try {
$steppablePipeline.End()
} catch {
throw
}
}
<#
.ForwardHelpTargetName Write-Verbose
.ForwardHelpCategory Cmdlet
#>
}
function Write-WarningLog {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
[Alias('Msg')]
[AllowEmptyString()]
[System.String]
${Message}
,
[Parameter(Mandatory=$false, Position=99)]
${Logger})
begin
{
try {
if($PSBoundParameters.ContainsKey("Logger")) {
if($Logger -is [log4net.Core.LogImpl]) { Set-Logger $Logger } else { $script:Logger = Get-Logger "$Logger" }
$null = $PSBoundParameters.Remove("Logger")
}
$outBuffer = $null
if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
{
$PSBoundParameters['OutBuffer'] = 1
}
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Write-Warning', [System.Management.Automation.CommandTypes]::Cmdlet)
$scriptCmd = {& $wrappedCmd @PSBoundParameters }
$steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
$steppablePipeline.Begin($PSCmdlet)
} catch {
throw
}
}
process
{
try {
$script:logger.Warn($Message) #Write-Warning
$steppablePipeline.Process($_)
} catch {
throw
}
}
end
{
try {
$steppablePipeline.End()
} catch {
throw
}
}
<#
.ForwardHelpTargetName Write-Warning
.ForwardHelpCategory Cmdlet
#>
}
function Write-ErrorLog {
[CmdletBinding(DefaultParameterSetName='NoException')]
param(
[Parameter(ParameterSetName='WithException', Mandatory=$true)]
[System.Exception]
${Exception},
[Parameter(ParameterSetName='NoException', Mandatory=$true, Position=0, ValueFromPipeline=$true)]
[Parameter(ParameterSetName='WithException')]
[Alias('Msg')]
[AllowNull()]
[AllowEmptyString()]
[System.String]
${Message},
[Parameter(ParameterSetName='ErrorRecord', Mandatory=$true)]
[System.Management.Automation.ErrorRecord]
${ErrorRecord},
[Parameter(ParameterSetName='NoException')]
[Parameter(ParameterSetName='WithException')]
[System.Management.Automation.ErrorCategory]
${Category},
[Parameter(ParameterSetName='WithException')]
[Parameter(ParameterSetName='NoException')]
[System.String]
${ErrorId},
[Parameter(ParameterSetName='NoException')]
[Parameter(ParameterSetName='WithException')]
[System.Object]
${TargetObject},
[System.String]
${RecommendedAction},
[Alias('Activity')]
[System.String]
${CategoryActivity},
[Alias('Reason')]
[System.String]
${CategoryReason},
[Alias('TargetName')]
[System.String]
${CategoryTargetName},
[Alias('TargetType')]
[System.String]
${CategoryTargetType}
,
[Parameter(Mandatory=$false, Position=99)]
${Logger})
begin
{
try {
if($PSBoundParameters.ContainsKey("Logger")) {
if($Logger -is [log4net.Core.LogImpl]) { Set-Logger $Logger } else { $script:Logger = Get-Logger "$Logger" }
$null = $PSBoundParameters.Remove("Logger")
}
$outBuffer = $null
if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
{
$PSBoundParameters['OutBuffer'] = 1
}
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Write-Error', [System.Management.Automation.CommandTypes]::Cmdlet)
$scriptCmd = {& $wrappedCmd @PSBoundParameters }
$steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
$steppablePipeline.Begin($PSCmdlet)
} catch {
throw
}
}
process
{
try {
$script:logger.ErrorException($Message,$Exception) #Write-Error
$steppablePipeline.Process($_)
} catch {
throw
}
}
end
{
try {
$steppablePipeline.End()
} catch {
throw
}
}
<#
.ForwardHelpTargetName Write-Error
.ForwardHelpCategory Cmdlet
#>
}
function Write-HostLog {
[CmdletBinding()]
param(
[Parameter(Position=0, ValueFromPipeline=$true, ValueFromRemainingArguments=$true)]
[System.Object]
${Object},
[Switch]
${NoNewline},
[System.Object]
${Separator} = $OFS,
[System.ConsoleColor]
${ForegroundColor},
[System.ConsoleColor]
${BackgroundColor}
,
[Parameter(Mandatory=$false, Position=99)]
${Logger})
begin
{
try {
if($PSBoundParameters.ContainsKey("Logger")) {
if($Logger -is [log4net.Core.LogImpl]) { Set-Logger $Logger } else { $script:Logger = Get-Logger "$Logger" }
$null = $PSBoundParameters.Remove("Logger")
}
$outBuffer = $null
if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
{
$PSBoundParameters['OutBuffer'] = 1
}
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Write-Host', [System.Management.Automation.CommandTypes]::Cmdlet)
$scriptCmd = {& $wrappedCmd @PSBoundParameters }
$steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
$steppablePipeline.Begin($PSCmdlet)
} catch {
throw
}
}
process
{
try {
$script:logger.Info(($Object -join $Separator)) #Write-Verbose
$steppablePipeline.Process($_)
} catch {
throw
}
}
end
{
try {
$steppablePipeline.End()
} catch {
throw
}
}
<#
.ForwardHelpTargetName Write-Host
.ForwardHelpCategory Cmdlet
#>
}
Set-Alias Write-Debug Write-DebugLog
Set-Alias Write-Verbose Write-VerboseLog
Set-Alias Write-Warning Write-WarningLog
Set-Alias Write-Error Write-ErrorLog
#Set-Alias Write-Host Write-HostLog
Export-ModuleMember -Function * -Alias *
$NLogLoggersCollection = @()
$script:Logger = Get-Logger "PowerShellLogger" -File # -Console -Growl
## THIS IS THE DEFAULT LOGGER. CONFIGURE AS YOU SEE FIT