File size: 15,246 Bytes
8c763fb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#if !UNIX
using System.Diagnostics.Eventing;
using System.Management.Automation.Internal;
using System.Text;
using System.Collections.Generic;
namespace System.Management.Automation.Tracing
{
/// <summary>
/// ETW log provider implementation.
/// </summary>
internal class PSEtwLogProvider : LogProvider
{
private static readonly EventProvider etwProvider;
internal static readonly Guid ProviderGuid = new Guid("F90714A8-5509-434A-BF6D-B1624C8A19A2");
private static readonly EventDescriptor _xferEventDescriptor = new EventDescriptor(0x1f05, 0x1, 0x11, 0x5, 0x14, 0x0, (long)0x4000000000000000);
/// <summary>
/// Class constructor.
/// </summary>
static PSEtwLogProvider()
{
etwProvider = new EventProvider(ProviderGuid);
}
/// <summary>
/// Determines whether any session is requesting the specified event from the provider.
/// </summary>
/// <param name="level"></param>
/// <param name="keywords"></param>
/// <returns></returns>
/// <remarks>
/// Typically, a provider does not call this method to determine whether a session requested the specified event;
/// the provider simply writes the event, and ETW determines whether the event is logged to a session. A provider
/// may want to call this function if the provider needs to perform extra work to generate the event. In this case,
/// calling this function first to determine if a session requested the event or not, may save resources and time.
/// </remarks>
internal bool IsEnabled(PSLevel level, PSKeyword keywords)
{
return etwProvider.IsEnabled((byte)level, (long)keywords);
}
/// <summary>
/// Provider interface function for logging health event.
/// </summary>
/// <param name="logContext"></param>
/// <param name="eventId"></param>
/// <param name="exception"></param>
/// <param name="additionalInfo"></param>
internal override void LogEngineHealthEvent(LogContext logContext, int eventId, Exception exception, Dictionary<string, string> additionalInfo)
{
StringBuilder payload = new StringBuilder();
AppendException(payload, exception);
payload.AppendLine();
AppendAdditionalInfo(payload, additionalInfo);
WriteEvent(PSEventId.Engine_Health, PSChannel.Operational, PSOpcode.Exception, PSTask.ExecutePipeline, 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>
/// Provider interface function for logging command health event.
/// </summary>
/// <param name="logContext"></param>
/// <param name="exception"></param>
internal override void LogCommandHealthEvent(LogContext logContext, Exception exception)
{
StringBuilder payload = new StringBuilder();
AppendException(payload, exception);
WriteEvent(PSEventId.Command_Health, PSChannel.Operational, PSOpcode.Exception, PSTask.ExecutePipeline, logContext, payload.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 = new StringBuilder();
if (logContext.CommandType != null)
{
if (logContext.CommandType.Equals(StringLiterals.Script, StringComparison.OrdinalIgnoreCase))
{
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.ScriptStateChange, newState.ToString()));
}
else
{
if (newState == CommandState.Stopped ||
newState == CommandState.Terminated)
{
// When state is stopped or terminated only log the CommandName
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext, newState.ToString()));
}
else
{
// When state is Start log the CommandLine which has arguments for completeness.
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext.CommandLine, 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());
}
}
/// <summary>
/// Provider interface function for logging pipeline execution detail.
/// </summary>
/// <param name="logContext"></param>
/// <param name="pipelineExecutionDetail"></param>
internal override void LogPipelineExecutionDetailEvent(LogContext logContext, List<string> pipelineExecutionDetail)
{
StringBuilder payload = new StringBuilder();
if (pipelineExecutionDetail != null)
{
foreach (string detail in pipelineExecutionDetail)
{
payload.AppendLine(detail);
}
}
WriteEvent(PSEventId.Pipeline_Detail, PSChannel.Operational, PSOpcode.Method, PSTask.ExecutePipeline, logContext, payload.ToString());
}
/// <summary>
/// Provider interface function for logging provider health event.
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="exception"></param>
internal override void LogProviderHealthEvent(LogContext logContext, string providerName, Exception exception)
{
StringBuilder payload = new StringBuilder();
AppendException(payload, exception);
payload.AppendLine();
Dictionary<string, string> additionalInfo = new Dictionary<string, string>();
additionalInfo.Add(EtwLoggingStrings.ProviderNameString, providerName);
AppendAdditionalInfo(payload, additionalInfo);
WriteEvent(PSEventId.Provider_Health, PSChannel.Operational, PSOpcode.Exception, PSTask.ExecutePipeline, logContext, payload.ToString());
}
/// <summary>
/// Provider interface function for logging provider health event.
/// </summary>
/// <param name="state">This the action performed in AmsiUtil class, like init, scan, etc.</param>
/// <param name="context">The amsiContext handled - Session pair.</param>
internal override void LogAmsiUtilStateEvent(string state, string context)
{
WriteEvent(PSEventId.Amsi_Init, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, PSTask.Amsi, (PSKeyword)0x0, state, context);
}
/// <summary>
/// Provider interface function for logging WDAC query event.
/// </summary>
/// <param name="queryName">Name of the WDAC query.</param>
/// <param name="fileName">Name of script file for policy query. Can be null value.</param>
/// <param name="querySuccess">Query call succeed code.</param>
/// <param name="queryResult">Result code of WDAC query.</param>
internal override void LogWDACQueryEvent(
string queryName,
string fileName,
int querySuccess,
int queryResult)
{
WriteEvent(PSEventId.WDAC_Query, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, PSTask.WDAC, (PSKeyword)0x0, queryName, fileName, querySuccess, queryResult);
}
/// <summary>
/// Provider interface function for logging WDAC audit event.
/// </summary>
/// <param name="title">Title of WDAC audit event.</param>
/// <param name="message">WDAC audit event message.</param>
/// <param name="fqid">FullyQualifiedId of WDAC audit event.</param>
internal override void LogWDACAuditEvent(
string title,
string message,
string fqid)
{
WriteEvent(PSEventId.WDAC_Audit, PSChannel.Operational, PSOpcode.Method, PSLevel.Informational, PSTask.WDACAudit, (PSKeyword)0x0, title, message, fqid);
}
/// <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 = new StringBuilder();
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 settings event.
/// </summary>
/// <param name="logContext"></param>
/// <param name="variableName"></param>
/// <param name="value"></param>
/// <param name="previousValue"></param>
internal override void LogSettingsEvent(LogContext logContext, string variableName, string value, string previousValue)
{
if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic))
{
StringBuilder payload = new StringBuilder();
if (previousValue == null)
{
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.SettingChangeNoPrevious, variableName, value));
}
else
{
payload.AppendLine(StringUtil.Format(EtwLoggingStrings.SettingChange, variableName, previousValue, value));
}
WriteEvent(PSEventId.Settings, PSChannel.Analytic, PSOpcode.Method, PSTask.ExecutePipeline, logContext, payload.ToString());
}
}
/// <summary>
/// The ETW provider does not use logging variables.
/// </summary>
/// <returns></returns>
internal override bool UseLoggingVariables()
{
return false;
}
/// <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)
{
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(in desc, args);
}
/// <summary>
/// Writes an activity transfer event.
/// </summary>
internal void WriteTransferEvent(Guid parentActivityId)
{
etwProvider.WriteTransferEvent(in _xferEventDescriptor, parentActivityId, EtwActivity.GetActivityId(), parentActivityId);
}
/// <summary>
/// </summary>
/// <param name="newActivityId"></param>
internal void SetActivityIdForCurrentThread(Guid newActivityId)
{
Guid result = newActivityId;
EventProvider.SetActivityId(ref result);
}
}
}
#endif
|