internal override void WriteWarning(
PSEventId id,
PSOpcode opcode,
PSTask task,
params object[] args)
{
}
/// <summary>
/// Writes a log entry.
/// </summary>
/// <param name="eventId">The event id of the log entry.</param>
/// <param name="channel">The channel to log.</param>
/// <param name="task">The task for the log entry.</param>
/// <param name="opcode">The operation for the log entry.</param>
/// <param name="level">The logging level.</param>
/// <param name="keyword">The keyword(s) for the event.</param>
/// <param name="args">The payload for the log message.</param>
public void Log(PSEventId eventId, PSChannel channel, PSTask task, PSOpcode opcode, PSLevel level, PSKeyword keyword, params object[] args)
{
if (ShouldLog(level, keyword, channel))
{
int threadId = Thread.CurrentThread.ManagedThreadId;
StringBuilder sb = MessageBuilder;
sb.Clear();
// add the message preamble
sb.AppendFormat(CultureInfo.InvariantCulture,
"({0}:{1:X}:{2:X}) [{3:G}:{4:G}.{5:G}.{6:G}] ",
PSVersionInfo.GitCommitId, threadId, channel, eventId, task, opcode, level);
// add the message
GetEventMessage(sb, eventId, args);
NativeMethods.SysLogPriority priority;
if ((int)level <= _levels.Length)
{
priority = _levels[(int)level];
}
else
{
priority = NativeMethods.SysLogPriority.Info;
}
// log it.
NativeMethods.SysLog(priority, sb.ToString());
}
}
/// <summary>
/// Provider interface function for logging command lifecycle event
/// </summary>
/// <param name="getLogContext"></param>
/// <param name="newState"></param>
///
internal override void LogCommandLifecycleEvent(Func <LogContext> getLogContext, CommandState newState)
{
if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
LogContext logContext = getLogContext();
StringBuilder payload = PayloadBuilder;
payload.Clear();
if (logContext.CommandType != null)
{
if (logContext.CommandType.Equals(StringLiterals.Script, StringComparison.OrdinalIgnoreCase))
{
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.ScriptStateChange, newState.ToString()));
}
else
{
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext.CommandName, newState.ToString()));
}
}
PSTask task = PSTask.CommandStart;
if (newState == CommandState.Stopped ||
newState == CommandState.Terminated)
{
task = PSTask.CommandStop;
}
WriteEvent(PSEventId.Command_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString());
}
}
internal override void WriteInformation(
PSEventId id,
PSOpcode opcode,
PSTask task,
params object[] args)
{
}
/// <summary>
/// Writes a single event
/// </summary>
/// <param name="id">event id</param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext">log context</param>
/// <param name="payLoad"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
s_provider.Log(id, channel, task, opcode, GetPSLevelFromSeverity(logContext.Severity), DefaultKeywords,
LogContextToString(logContext),
GetPSLogUserData(logContext.ExecutionContext),
payLoad);
}
internal override void LogCommandLifecycleEvent(Func <LogContext> getLogContext, CommandState newState)
{
if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
LogContext logContext = getLogContext();
StringBuilder builder = new StringBuilder();
if (logContext.CommandType != null)
{
if (logContext.CommandType.Equals("SCRIPT", StringComparison.OrdinalIgnoreCase))
{
builder.AppendLine(StringUtil.Format(EtwLoggingStrings.ScriptStateChange, newState.ToString()));
}
else
{
builder.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext.CommandName, newState.ToString()));
}
}
PSTask commandStart = PSTask.CommandStart;
if ((newState == CommandState.Stopped) || (newState == CommandState.Terminated))
{
commandStart = PSTask.CommandStop;
}
this.WriteEvent(PSEventId.Command_Lifecycle, PSChannel.Analytic, PSOpcode.Method, commandStart, logContext, builder.ToString());
}
}
internal override void WriteCritialError(
PSEventId id,
PSOpcode opcode,
PSTask task,
params object[] args)
{
}
public async Task <IActionResult> PutPSTask(int id, PSTask pSTask)
{
if (id != pSTask.Id)
{
return(BadRequest());
}
_context.Entry(pSTask).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PSTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
internal override void ReplaceActivityIdForCurrentThread(
Guid newActivityId,
PSEventId eventForOperationalChannel,
PSEventId eventForAnalyticChannel,
PSKeyword keyword,
PSTask task)
{
}
internal override void WriteTransferEvent(
Guid relatedActivityId,
PSEventId eventForOperationalChannel,
PSEventId eventForAnalyticChannel,
PSKeyword keyword,
PSTask task)
{
}
internal override void WriteEvent(
PSEventId id,
PSLevel level,
PSOpcode opcode,
PSTask task,
params object[] args)
{
}
static internal void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword,
Int64 objectId,
Int64 fragmentId,
int isStartFragment,
int isEndFragment,
UInt32 fragmentLength,
PSETWBinaryBlob fragmentData)
{
}
internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, long objectId, long fragmentId, int isStartFragment, int isEndFragment, int fragmentLength, PSETWBinaryBlob fragmentData)
{
if (provider.IsEnabled(PSLevel.Verbose, keyword))
{
string str = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length);
str = string.Format(CultureInfo.InvariantCulture, "0x{0}", new object[] { str.Replace("-", "") });
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword, new object[] { objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength, str });
}
}
internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, long objectId, long fragmentId, int isStartFragment, int isEndFragment, int fragmentLength, PSETWBinaryBlob fragmentData)
{
if (provider.IsEnabled(PSLevel.Verbose, keyword))
{
string str = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length);
str = string.Format(CultureInfo.InvariantCulture, "0x{0}", new object[] { str.Replace("-", "") });
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword, new object[] { objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength, str });
}
}
public async Task <ActionResult <PSTask> > PostPSTask(PSTask pSTask)
{
if (pSTask.User != null && pSTask.User.Id != 0)
{
return(BadRequest());
}
_context.PSTask.Add(pSTask);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPSTask", new { id = pSTask.Id }, pSTask));
}
internal override void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState)
{
if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
StringBuilder builder = new StringBuilder();
builder.AppendLine(StringUtil.Format(EtwLoggingStrings.EngineStateChange, previousState.ToString(), newState.ToString()));
PSTask engineStart = PSTask.EngineStart;
if (((newState == EngineState.Stopped) || (newState == EngineState.OutOfService)) || ((newState == EngineState.None) || (newState == EngineState.Degraded)))
{
engineStart = PSTask.EngineStop;
}
this.WriteEvent(PSEventId.Engine_Lifecycle, PSChannel.Analytic, PSOpcode.Method, engineStart, logContext, builder.ToString());
}
}
internal override void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState)
{
if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
StringBuilder builder = new StringBuilder();
builder.AppendLine(StringUtil.Format(EtwLoggingStrings.ProviderStateChange, providerName, newState.ToString()));
PSTask providerStart = PSTask.ProviderStart;
if (newState == ProviderState.Stopped)
{
providerStart = PSTask.ProviderStop;
}
this.WriteEvent(PSEventId.Provider_Lifecycle, PSChannel.Analytic, PSOpcode.Method, providerStart, logContext, builder.ToString());
}
}
/// <summary>
/// Logs remoting fragment data to verbose channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="objectId"></param>
/// <param name="fragmentId"></param>
/// <param name="isStartFragment"></param>
/// <param name="isEndFragment"></param>
/// <param name="fragmentLength"></param>
/// <param name="fragmentData"></param>
internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword,
Int64 objectId,
Int64 fragmentId,
int isStartFragment,
int isEndFragment,
UInt32 fragmentLength,
PSETWBinaryBlob fragmentData)
{
if (provider.IsEnabled(PSLevel.Verbose, keyword))
{
string payLoadData = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length);
payLoadData = string.Format(CultureInfo.InvariantCulture, "0x{0}", payLoadData.Replace("-", string.Empty));
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword,
objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength,
payLoadData);
}
}
/// <summary>
/// Provider interface function for logging provider lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="newState"></param>
internal override void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState)
{
if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
StringBuilder payload = PayloadBuilder;
payload.Clear();
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.ProviderStateChange, providerName, newState.ToString()));
PSTask task = PSTask.ProviderStart;
if (newState == ProviderState.Stopped)
{
task = PSTask.ProviderStop;
}
WriteEvent(PSEventId.Provider_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString());
}
}
/// <summary>
/// Provider interface function for logging engine lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="newState"></param>
/// <param name="previousState"></param>
internal override void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState)
{
if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
StringBuilder payload = new StringBuilder();
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.EngineStateChange, previousState.ToString(), newState.ToString()));
PSTask task = PSTask.EngineStart;
if (newState == EngineState.Stopped ||
newState == EngineState.OutOfService ||
newState == EngineState.None ||
newState == EngineState.Degraded)
{
task = PSTask.EngineStop;
}
WriteEvent(PSEventId.Engine_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString());
}
}
/// <summary>
/// Writes a log entry.
/// </summary>
/// <param name="eventId">The event id of the log entry.</param>
/// <param name="channel">The channel to log.</param>
/// <param name="task">The task for the log entry.</param>
/// <param name="opcode">The operation for the log entry.</param>
/// <param name="level">The logging level.</param>
/// <param name="keyword">The keyword(s) for the event.</param>
/// <param name="args">The payload for the log message.</param>
public void Log(PSEventId eventId, PSChannel channel, PSTask task, PSOpcode opcode, PSLevel level, PSKeyword keyword, params object[] args)
{
if (keyword == PSKeyword.UseAlwaysAnalytic)
{
// Use the 'DefaultKeywords' to work around the default keyword filter.
// Note that the PSKeyword argument is not really used in writing SysLog.
keyword = PSSysLogProvider.DefaultKeywords;
}
if (ShouldLog(level, keyword, channel))
{
int threadId = Thread.CurrentThread.ManagedThreadId;
StringBuilder sb = MessageBuilder;
sb.Clear();
// add the message preamble
sb.AppendFormat(CultureInfo.InvariantCulture,
"({0}:{1:X}:{2:X}) [{3:G}:{4:G}.{5:G}.{6:G}] ",
PSVersionInfo.GitCommitId, threadId, channel, eventId, task, opcode, level);
// add the message
GetEventMessage(sb, eventId, args);
NativeMethods.SysLogPriority priority;
if ((int)level <= _levels.Length)
{
priority = _levels[(int)level];
}
else
{
priority = NativeMethods.SysLogPriority.Info;
}
// log it.
NativeMethods.SysLog(priority, sb.ToString());
}
}
/// <summary>
/// Logs error message to the operational channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext"></param>
/// <param name="payLoad"></param>
internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
provider.WriteEvent(id, PSChannel.Operational, opcode, task, logContext, payLoad);
}
internal static void ReplaceActivityIdForCurrentThread(Guid newActivityId,
PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task)
{
// set the new activity id
provider.SetActivityIdForCurrentThread(newActivityId);
// Once the activity id is set, write the transfer event
WriteTransferEvent(newActivityId, eventForOperationalChannel, eventForAnalyticChannel, keyword, task);
}
/// <summary>
/// Logs informational message to the analytic channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal static void LogAnalyticInformational(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args)
{
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Informational, task, keyword, args);
}
/// <summary>
/// Logs error message to operation channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args)
{
provider.WriteEvent(id, PSChannel.Operational, opcode, PSLevel.Error, task, keyword, args);
}
static internal void LogOperationalInformation(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { }
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
long keywords = 0L;
if ((keyword == PSKeyword.UseAlwaysAnalytic) || (keyword == PSKeyword.UseAlwaysOperational))
{
keywords = 0L;
}
else
{
keywords = (long) keyword;
}
System.Diagnostics.Eventing.EventDescriptor eventDescriptor = new System.Diagnostics.Eventing.EventDescriptor((int) id, 1, (byte) channel, (byte) level, (byte) opcode, (int) task, keywords);
etwProvider.WriteEvent(ref eventDescriptor, args);
}
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
long keywords = 0L;
if ((keyword == PSKeyword.UseAlwaysAnalytic) || (keyword == PSKeyword.UseAlwaysOperational))
{
keywords = 0L;
}
else
{
keywords = (long)keyword;
}
System.Diagnostics.Eventing.EventDescriptor eventDescriptor = new System.Diagnostics.Eventing.EventDescriptor((int)id, 1, (byte)channel, (byte)level, (byte)opcode, (int)task, keywords);
etwProvider.WriteEvent(ref eventDescriptor, args);
}
/// <summary>
/// Writes an event
/// </summary>
/// <param name="id"></param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="level"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
long longKeyword = 0x00;
if (keyword == PSKeyword.UseAlwaysAnalytic ||
keyword == PSKeyword.UseAlwaysOperational)
{
longKeyword = 0x00;
}
else
{
longKeyword = (long)keyword;
}
EventDescriptor desc = new EventDescriptor((int)id, (byte)PSEventVersion.One, (byte)channel,
(byte)level, (byte)opcode, (int)task, longKeyword);
etwProvider.WriteEvent(ref desc, args);
}
static internal void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { }
static internal void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword,
Int64 objectId,
Int64 fragmentId,
int isStartFragment,
int isEndFragment,
UInt32 fragmentLength,
PSETWBinaryBlob fragmentData)
{ }
static internal void ReplaceActivityIdForCurrentThread(Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { }
/// <summary>
/// Writes an event
/// </summary>
/// <param name="id"></param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="level"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
long longKeyword = 0x00;
if (keyword == PSKeyword.UseAlwaysAnalytic ||
keyword == PSKeyword.UseAlwaysOperational)
{
longKeyword = 0x00;
}
else
{
longKeyword = (long)keyword;
}
EventDescriptor desc = new EventDescriptor((int)id, (byte)PSEventVersion.One, (byte)channel,
(byte)level, (byte)opcode, (int)task, longKeyword);
etwProvider.WriteEvent(ref desc, args);
}
static internal void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { }
/// <summary>
/// Writes a transfer event mapping current activity id
/// with a related activity id
/// This function writes a transfer event for both the
/// operational and analytic channels.
/// </summary>
/// <param name="relatedActivityId"></param>
/// <param name="eventForOperationalChannel"></param>
/// <param name="eventForAnalyticChannel"></param>
/// <param name="keyword"></param>
/// <param name="task"></param>
internal static void WriteTransferEvent(Guid relatedActivityId, PSEventId eventForOperationalChannel,
PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task)
{
provider.WriteEvent(eventForOperationalChannel, PSChannel.Operational, PSOpcode.Method, PSLevel.Informational, task,
PSKeyword.UseAlwaysOperational);
provider.WriteEvent(eventForAnalyticChannel, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, task,
PSKeyword.UseAlwaysAnalytic);
}
static void Main(string[] args)
{
Console.WriteLine("Main function's AppDomain: " + AppDomain.CurrentDomain.FriendlyName);
PSTaskManager TaskManager = new PSTaskManager();
while (true)
{
StringBuilder output = new StringBuilder();
// 1. Check for any pending commands (new job, kill job(s), list job(s), checkin on job)
string input = RecieveInput();
// 2. Execute incoming command (new job, status, stop, exit, etc.)
List <PSTask> tasks = TaskManager.GetAllTasks();
if (input == "status")
{
foreach (PSTask task in tasks)
{
Console.WriteLine(task.ID + "\t" + task.GetStatus());
}
}
else if (input == "exit")
{
try
{
TaskManager.KillAllTasks();
}
catch (Exception e)
{
// Do something with the error...
SendOutput(e.ToString());
}
// TODO: Return the output of any tasks here...
break;
}
else if (input != String.Empty)
{
int TaskID = TaskManager.Execute(input);
// 2b. Return the TaskID
}
// 3. Remove stopped/completed jobs and store output
// Count backwards so we don't skip anything in case we have to remove something
for (int i = tasks.Count - 1; i >= 0; i--)
{
PSTask t = tasks[i];
PipelineState status = t.GetStatus();
if (status == PipelineState.Completed || status == PipelineState.Failed || status == PipelineState.Stopped)
{
// Step 3b. - Create the return data structure
output.Append("\n\n\n************ Task " + t.ID + " Output ************\n");
output.Append("Status: " + t.GetStatus() + "\n");
output.Append("Output: " + t.GetOutput());
// Step 3c. - Destroy/remove the job
try
{
TaskManager.KillTask(t.ID);
}
catch (Exception e)
{
// Do something with the error...
SendOutput(e.ToString());
}
}
}
// Step 3b - Manually invoke the garbage collector to free decrease memory usage...
InvokeGarbageCollector();
// 4. Return output (output from steps 2 and 3)
SendOutput(output.ToString());
}
}
/// <summary>
/// Writes a single event
/// </summary>
/// <param name="id">event id.</param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext">log context.</param>
/// <param name="payLoad"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
WriteEvent(id, channel, opcode, GetPSLevelFromSeverity(logContext.Severity), task, (PSKeyword)0x0,
LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad);
}
/// <summary>
/// Writes an event
/// </summary>
/// <param name="id"></param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="level"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
s_provider.Log(id, channel, task, opcode, level, keyword, args);
}
/// <summary>
/// Logs error message to operation channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args)
{
provider.WriteEvent(id, PSChannel.Operational, opcode, PSLevel.Error, task, keyword, args);
}
/// <summary>
/// Logs remoting fragment data to verbose channel.
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="objectId"></param>
/// <param name="fragmentId"></param>
/// <param name="isStartFragment"></param>
/// <param name="isEndFragment"></param>
/// <param name="fragmentLength"></param>
/// <param name="fragmentData"></param>
internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword,
Int64 objectId,
Int64 fragmentId,
int isStartFragment,
int isEndFragment,
UInt32 fragmentLength,
PSETWBinaryBlob fragmentData)
{
if (provider.IsEnabled(PSLevel.Verbose, keyword))
{
string payLoadData = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length);
payLoadData = string.Format(CultureInfo.InvariantCulture, "0x{0}", payLoadData.Replace("-", ""));
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword,
objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength,
payLoadData);
}
}
/// <summary>
/// Logs informational message to the analytic channel
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="keyword"></param>
/// <param name="args"></param>
internal static void LogAnalyticInformational(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args)
{
provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Informational, task, keyword, args);
}
internal static void ReplaceActivityIdForCurrentThread(Guid newActivityId,
PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task)
{
// set the new activity id
provider.SetActivityIdForCurrentThread(newActivityId);
// Once the activity id is set, write the transfer event
WriteTransferEvent(newActivityId, eventForOperationalChannel, eventForAnalyticChannel, keyword, task);
}
/// <summary>
/// Logs error message to the operational channel
/// </summary>
/// <param name="id"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext"></param>
/// <param name="payLoad"></param>
internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
provider.WriteEvent(id, PSChannel.Operational, opcode, task, logContext, payLoad);
}
/// <summary>
/// Writes a single event
/// </summary>
/// <param name="id">event id</param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext">log context</param>
/// <param name="payLoad"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
WriteEvent(id, channel, opcode, GetPSLevelFromSeverity(logContext.Severity), task, (PSKeyword)0x0,
LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad);
}
/// <summary>
/// Writes a transfer event mapping current activity id
/// with a related activity id
/// This function writes a transfer event for both the
/// operational and analytic channels
/// </summary>
/// <param name="relatedActivityId"></param>
/// <param name="eventForOperationalChannel"></param>
/// <param name="eventForAnalyticChannel"></param>
/// <param name="keyword"></param>
/// <param name="task"></param>
internal static void WriteTransferEvent(Guid relatedActivityId, PSEventId eventForOperationalChannel,
PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task)
{
provider.WriteEvent(eventForOperationalChannel, PSChannel.Operational, PSOpcode.Method, PSLevel.Informational, task,
PSKeyword.UseAlwaysOperational);
provider.WriteEvent(eventForAnalyticChannel, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, task,
PSKeyword.UseAlwaysAnalytic);
}
internal static void ReplaceActivityIdForCurrentThread(Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task)
{
provider.SetActivityIdForCurrentThread(newActivityId);
WriteTransferEvent(newActivityId, eventForOperationalChannel, eventForAnalyticChannel, keyword, task);
}
