public void LogFault(Exception ex, string description, bool dumpProcess)
{
var session = _session.Value;
// No session is not a fatal error
if (session == null)
{
return;
}
// Never send events when users have not opted in.
if (!session.IsOptedIn)
{
return;
}
var fault = new FaultEvent(
EventPrefix + "UnhandledException",
!string.IsNullOrEmpty(description) ? description : "Unhandled exception in Python extension.",
ex
);
if (dumpProcess)
{
fault.AddProcessDump(Process.GetCurrentProcess().Id);
fault.IsIncludedInWatsonSample = true;
}
else
{
fault.IsIncludedInWatsonSample = false;
}
session.PostEvent(fault);
}
// pretty print a fault statement to the console
internal virtual void dumpFaultLine(FaultEvent e)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// use a slightly different format for ConsoleErrorFaults
if (e is ConsoleErrorFault)
{
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingConsoleError")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(e.information);
}
else
{
String name = e.name();
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingFault")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(name);
if (e.information != null && e.information.Length > 0)
{
sb.Append(TextHelper.GetString("Info.InformationAboutFault")); //$NON-NLS-1$
sb.Append(e.information);
}
}
TraceManager.AddAsync(sb.ToString(), 3);
}
// assign the object o, the value v; returns Boolean true if worked, false if failed
public virtual Object assign(Object o, Object v)
{
bool worked = false;
try
{
Variable var = resolveToVariable(o);
if (var == null)
{
throw new NoSuchVariableException(m_current);
}
// set the value, for the case of a variable that does not exist it will not have a type
// so we try to glean one from v.
int type = determineType(var, v);
FaultEvent faultEvent = var.setValue(type, v.ToString());
if (faultEvent != null)
{
throw new PlayerFaultException(faultEvent);
}
worked = true;
}
catch (PlayerDebugException)
{
worked = false;
}
return(worked);
}
async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception);
IPipe <SendContext <Fault <T> > > faultPipe = Pipe.Execute <SendContext <Fault <T> > >(x =>
{
x.TransferConsumeContextHeaders(context);
x.CorrelationId = context.CorrelationId;
x.RequestId = context.RequestId;
});
var destinationAddress = FaultAddress ?? ResponseAddress;
if (destinationAddress != null)
{
var endpoint = await GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await endpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
else
{
await Publish(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
public static async Task PostFaultAsync(Exception e, string callerClassName, [CallerMemberName] string callerMemberName = null, IDictionary <string, object> extraProperties = null)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
var caller = $"{callerClassName}.{callerMemberName}";
var description = $"{e.GetType().Name} - {e.Message}";
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var fault = new FaultEvent(VSTelemetrySession.VSEventNamePrefix + "Fault", description, FaultSeverity.General, e, gatherEventDetails: null);
fault.Properties[$"{VSTelemetrySession.VSPropertyNamePrefix}Fault.Caller"] = caller;
if (extraProperties != null)
{
foreach (var kvp in extraProperties)
{
fault.Properties[VSTelemetrySession.VSEventNamePrefix + kvp.Key] = kvp.Value;
}
}
TelemetryService.DefaultSession.PostEvent(fault);
if (await IsShellAvailable.GetValueAsync())
{
ActivityLog.TryLogError(caller, description);
}
}
async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception);
IPipe <SendContext <Fault <T> > > faultPipe = Pipe.Execute <SendContext <Fault <T> > >(x =>
{
x.SourceAddress = ReceiveContext.InputAddress;
x.CorrelationId = CorrelationId;
x.RequestId = RequestId;
foreach (KeyValuePair <string, object> header in Headers.GetAll())
{
x.Headers.Set(header.Key, header.Value);
}
});
if (FaultAddress != null)
{
var endpoint = await GetSendEndpoint(FaultAddress).ConfigureAwait(false);
await endpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
else if (ResponseAddress != null)
{
var endpoint = await GetSendEndpoint(ResponseAddress).ConfigureAwait(false);
await endpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
else
{
await _publishEndpoint.Value.Publish(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
async Task GenerateFault <T>(T message, Exception exception)
where T : class
{
Fault <T> fault = new FaultEvent <T>(message, HostMetadataCache.Host, exception);
IPipe <SendContext <Fault <T> > > faultPipe = Pipe.New <SendContext <Fault <T> > >(x => x.UseExecute(v =>
{
v.SourceAddress = ReceiveContext.InputAddress;
v.CorrelationId = CorrelationId;
v.RequestId = RequestId;
foreach (var header in Headers.GetAll())
{
v.Headers.Set(header.Key, header.Value);
}
}));
if (ResponseAddress != null)
{
ISendEndpoint endpoint = await GetSendEndpoint(ResponseAddress).ConfigureAwait(false);
await endpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
else
{
await _publishEndpoint.Publish(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
private void OnFault(FaultEvent fault)
{
if (TestScenario != null)
{
TestScenario.Events.Enqueue(fault);
Console.WriteLine("Got fault event: {0}", fault);
}
}
public static void ReportNonFatal(Exception exception)
{
if (exception is OutOfMemoryException)
{
FailFast.OnFatalException(exception);
}
if (!s_report)
{
return;
}
var emptyCallstack = exception.SetCallstackIfEmpty();
var currentProcess = Process.GetCurrentProcess();
// write the exception to a log file:
s_logger?.TraceEvent(TraceEventType.Error, 1, $"[{currentProcess.ProcessName}:{currentProcess.Id}] Unexpected exception: {exception}");
var session = s_telemetrySession;
if (session == null)
{
return;
}
var logFilePaths = CaptureLogFiles();
var faultEvent = new FaultEvent(
eventName: FunctionId.NonFatalWatson.GetEventName(),
description: "Roslyn NonFatal Watson",
FaultSeverity.Diagnostic,
exceptionObject: exception,
gatherEventDetails: faultUtility =>
{
// add current process dump
faultUtility.AddProcessDump(currentProcess.Id);
// add ServiceHub log files:
foreach (var path in logFilePaths)
{
faultUtility.AddFile(path);
}
// Returning "0" signals that we should send data to Watson; any other value will cancel the Watson report.
return(0);
});
// add extra bucket parameters to bucket better in NFW
// we do it here so that it gets bucketted better in both
// watson and telemetry.
faultEvent.SetExtraParameters(exception, emptyCallstack);
session.PostEvent(faultEvent);
}
protected virtual async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception, context.SupportedMessageTypes.ToArray());
var faultPipe = new FaultPipe <T>(context);
var faultEndpoint = await this.GetFaultEndpoint <T>().ConfigureAwait(false);
await faultEndpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
public void PostFault(TelemetryIdentifier telemetryIdentifier, string description, Exception exception, IEnumerable <DataPoint> properties)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
if (telemetryIdentifier == null)
{
throw new ArgumentNullException("telemetryIdentifier");
}
FaultEvent val = (FaultEvent)(object)new FaultEvent(telemetryIdentifier.Value, description, exception, (Func <IFaultUtility, int>)SendFaultToWatson);
DataPointCollection.AddCollectionToDictionary(properties, ((TelemetryEvent)val).Properties);
telemetryRecorder.RecordEvent((TelemetryEvent)(object)val);
}
public bool PostFault(string eventName, Exception exceptionObject)
{
Requires.NotNullOrEmpty(eventName, nameof(eventName));
Requires.NotNull(exceptionObject, nameof(exceptionObject));
var faultEvent = new FaultEvent(eventName,
description: null,
exceptionObject);
PostTelemetryEvent(faultEvent);
return(true);
}
private int GetADCRegisterData()
{
//Shift MSB to the left 8 bits)
int RTDVala = GetRegister(0x01) << 8;
int RTDValb = GetRegister(0x02);
if ((GetRegister(0x02) & 0x01) > 0)
{
FaultEvent?.Invoke(this, GetRegister((byte)Register.FLT_STATUS));
}
//FaultEvent(this, );
//Merge bytes
return(RTDVala | RTDValb);
}
/// <summary>
/// Report Non-Fatal Watson
/// </summary>
/// <param name="description">any description you want to save with this watson report</param>
/// <param name="exception">Exception that triggered this non-fatal error</param>
/// <param name="callback">Callback to include extra data with the NFW. Note that we always collect
/// a dump of the current process, but this can be used to add further information or files to the
/// CAB.</param>
/// <param name="severity">indicate <see cref="WatsonSeverity"/> of NFW</param>
public static void Report(string description, Exception exception, Func <IFaultUtility, int> callback, WatsonSeverity severity = WatsonSeverity.Default)
{
var critical = severity == WatsonSeverity.Critical;
var emptyCallstack = exception.SetCallstackIfEmpty();
// if given exception is non recoverable exception,
// crash instead of NFW
if (IsNonRecoverableException(exception))
{
CodeAnalysis.FailFast.OnFatalException(exception);
}
if (!exception.ShouldReport())
{
return;
}
if (RoslynServices.SessionOpt == null)
{
return;
}
// in OOP, we don't fire Critical NFW, rather we fire General which is 1 level higher than Diagnostic
// and we keep fire NFW even after critical report.
// critical NFW regarding OOP from VS side will let us to prioritize NFW to fix, and NFW from here should provide
// extra dump/info to take a look.
// whenever there is an exception in OOP, we fire NFW in both VS and OOP side. VS will report it as critical NFW
// and OOP will fire normal NFW. we only mark VS side critical since we don't want to double report same issue
// and don't want to shutdown NFW in OOP
// one can correlate NFW from VS and OOP through remote callstack in VS NFW
var faultEvent = new FaultEvent(
eventName: FunctionId.NonFatalWatson.GetEventName(),
description: description,
critical ? FaultSeverity.General : FaultSeverity.Diagnostic,
exceptionObject: exception,
gatherEventDetails: arg =>
{
// always add current processes dump
arg.AddProcessDump(System.Diagnostics.Process.GetCurrentProcess().Id);
return(callback(arg));
});
// add extra bucket parameters to bucket better in NFW
// we do it here so that it gets bucketted better in both
// watson and telemetry.
faultEvent.SetExtraParameters(exception, emptyCallstack);
RoslynServices.SessionOpt.PostEvent(faultEvent);
}
public void PostFault(TelemetryIdentifier telemetryIdentifier, string description, Exception exception)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
if (telemetryIdentifier == null)
{
throw new ArgumentNullException("telemetryIdentifier");
}
FaultEvent val = (FaultEvent)(object)new FaultEvent(telemetryIdentifier.Value, description, exception, (Func <IFaultUtility, int>)SendFaultToWatson);
EndEvent.Correlate(((TelemetryEvent)val).Correlation);
TelemetryRecorder.RecordEvent((TelemetryEvent)(object)val);
}
protected virtual async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
if (context.ReceiveContext.PublishFaults || context.FaultAddress != null || context.ResponseAddress != null)
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception,
context.SupportedMessageTypes.ToArray());
var faultPipe = new FaultPipe <T>(context);
var faultEndpoint = context.ReceiveContext is InMemoryOutboxReceiveContext
? await this.GetFaultEndpoint <T>().ConfigureAwait(false)
: await context.GetFaultEndpoint <T>().ConfigureAwait(false);
await faultEndpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
private TReturn HandleFaultEvent <TReturn>(string methodName, Exception exceptionValue, object returnValue)
{
if (FaultListeners != null)
{
var faultEvent = new FaultEvent()
{
MethodName = methodName,
Exception = exceptionValue,
ReturnValue = returnValue
};
FaultListeners(faultEvent);
}
if (exceptionValue != null)
{
throw exceptionValue;
}
return((TReturn)returnValue);
}
public void PostFault(TelemetryIdentifier telemetryIdentifier, string description)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
if (telemetryIdentifier == null)
{
throw new ArgumentNullException("telemetryIdentifier");
}
if (string.IsNullOrEmpty(description))
{
throw new ArgumentNullException("description");
}
FaultEvent val = (FaultEvent)(object)new FaultEvent(telemetryIdentifier.Value, description, (Exception)null, (Func <IFaultUtility, int>)null);
EndEvent.Correlate(((TelemetryEvent)val).Correlation);
TelemetryRecorder.RecordEvent((TelemetryEvent)(object)val);
}
async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception);
var faultPipe = new FaultPipe <T>(context);
var destinationAddress = FaultAddress ?? ResponseAddress;
if (destinationAddress != null)
{
var endpoint = await GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await ConsumeTask(endpoint.Send(fault, faultPipe, CancellationToken)).ConfigureAwait(false);
}
else
{
await Publish(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Run an automatic fault scan
/// </summary>
public void RunAutoFltScan()
{
byte OldValue = GetRegister(0x00);
//Write 100x010x by keeping existing values for ...x...x and adding 0x84
byte NewValue = (byte)((OldValue & 0x11) | 0x84); //Everything by D5,D3 and D2...plus the falut clear bit
Debug.WriteLine("Run Fault Scan: Old:" + OldValue.ToString("X") + " New:" + NewValue.ToString("X"));
SetRegister(0x00, NewValue);
while ((GetRegister(0x00) & 0x0C) > 0)
{
;
}
byte FaultByte = GetRegister((byte)Register.FLT_STATUS);
if (FaultByte > 0)
{
FaultEvent?.Invoke(this, FaultByte);
}
}
protected virtual async Task GenerateFault <T>(ConsumeContext <T> context, Exception exception)
where T : class
{
if (context.ReceiveContext.PublishFaults || context.FaultAddress != null || context.ResponseAddress != null)
{
Fault <T> fault = new FaultEvent <T>(context.Message, context.MessageId, HostMetadataCache.Host, exception,
context.SupportedMessageTypes.ToArray());
var faultPipe = new FaultPipe <T>(context);
ConsumeContext faultContext = context;
while (faultContext.TryGetPayload <InMemoryOutboxConsumeContext>(out var outboxConsumeContext))
{
faultContext = outboxConsumeContext.CapturedContext;
}
var faultEndpoint = await faultContext.GetFaultEndpoint <T>().ConfigureAwait(false);
await faultEndpoint.Send(fault, faultPipe, CancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Report Non-Fatal Watson
/// </summary>
/// <param name="description">any description you want to save with this watson report</param>
/// <param name="exception">Exception that triggered this non-fatal error</param>
/// <param name="callback">Callback to include extra data with the NFW. Note that we always collect
/// a dump of the current process, but this can be used to add further information or files to the
/// CAB.</param>
public static void Report(string description, Exception exception, Func <IFaultUtility, int> callback)
{
var emptyCallstack = exception.SetCallstackIfEmpty();
// if given exception is non recoverable exception,
// crash instead of NFW
if (IsNonRecoverableException(exception))
{
CodeAnalysis.FailFast.OnFatalException(exception);
}
if (!exception.ShouldReport())
{
return;
}
if (SessionOpt == null)
{
return;
}
var faultEvent = new FaultEvent(
eventName: FunctionId.NonFatalWatson.GetEventName(),
description: description,
exceptionObject: exception,
gatherEventDetails: arg =>
{
// always add current processes dump
arg.AddProcessDump(System.Diagnostics.Process.GetCurrentProcess().Id);
return(callback(arg));
});
// add extra bucket parameters to bucket better in NFW
// we do it here so that it gets bucketted better in both
// watson and telemetry.
faultEvent.SetExtraParameters(exception, emptyCallstack);
SessionOpt.PostEvent(faultEvent);
}
/// <summary>
/// Report Non-Fatal Watson
/// </summary>
/// <param name="description">any description you want to save with this watson report</param>
/// <param name="exception">Exception that triggered this non-fatal error</param>
/// <param name="callback">Callback to include extra data with the NFW. Note that we always collect
/// a dump of the current process, but this can be used to add further information or files to the
/// CAB.</param>
/// <param name="severity">indicate <see cref="WatsonSeverity"/> of NFW</param>
public static void Report(string description, Exception exception, Func <IFaultUtility, int> callback, WatsonSeverity severity = WatsonSeverity.Default)
{
var critical = severity == WatsonSeverity.Critical;
var emptyCallstack = exception.SetCallstackIfEmpty();
if (!WatsonDisabled.s_reportWatson ||
!exception.ShouldReport())
{
return;
}
var faultEvent = new FaultEvent(
eventName: FunctionId.NonFatalWatson.GetEventName(),
description: description,
critical ? FaultSeverity.Critical : FaultSeverity.Diagnostic,
exceptionObject: exception,
gatherEventDetails: arg =>
{
// always add current processes dump
arg.AddProcessDump(System.Diagnostics.Process.GetCurrentProcess().Id);
return(callback(arg));
});
// add extra bucket parameters to bucket better in NFW
// we do it here so that it gets bucketted better in both
// watson and telemetry.
faultEvent.SetExtraParameters(exception, emptyCallstack);
TelemetryService.DefaultSession.PostEvent(faultEvent);
if (exception is OutOfMemoryException || critical)
{
// Once we've encountered one OOM or Critial NFW,
// we're likely to see more. There will probably be other
// failures as a direct result of the OOM or critical NFW, as well.
// These aren't helpful so we should just stop reporting failures.
WatsonDisabled.s_reportWatson = false;
}
}
public async Task Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
var consumeContext = context.CreateConsumeContext();
var requestToken = await requestTokenFactory?.Invoke(consumeContext);
var exception = await exceptionFactory?.Invoke(consumeContext);
var sendEndpoint = await consumeContext.GetSendEndpoint(requestToken.FaultAddress ?? requestToken.ResponseAddress);
var fault = new FaultEvent <TRequest>(requestToken.Request, requestToken.MessageId, HostMetadataCache.Host, exception, new string[0]);
await sendEndpoint.Send(fault, ctx =>
{
ctx.CorrelationId = requestToken.CorrelationId;
ctx.ConversationId = requestToken.ConversationId;
ctx.RequestId = requestToken.RequestId;
contextCallback?.Invoke(ctx);
});
await next.Execute(context).ConfigureAwait(false);
}
// assign the object o, the value v; returns Boolean true if worked, false if failed
public virtual Object assign(Object o, Object v)
{
bool worked = false;
try
{
// we expect that o is a variable that can be resolved or is a specially marked internal variable
if (o is InternalProperty)
{
worked = assignInternal((InternalProperty)o, v);
}
else
{
Variable var = resolveToVariable(o);
if (var == null)
{
throw new NoSuchVariableException(m_current);
}
// set the value, for the case of a variable that does not exist it will not have a type
// so we try to glean one from v.
int type = determineType(var, v);
FaultEvent faultEvent = var.setValue(type, v.ToString());
if (faultEvent != null)
{
throw new PlayerFaultException(faultEvent);
}
worked = true;
}
}
catch (PlayerDebugException)
{
worked = false;
}
return(worked);
}
public void RecordFault(string eventName, Exception ex, string description, bool dumpProcess)
{
if (this.IsEnabled)
{
var fault = new FaultEvent(
eventName,
!string.IsNullOrEmpty(description) ? description : "Unhandled exception in Cookiecutter extension.",
ex
);
if (dumpProcess)
{
fault.AddProcessDump(Process.GetCurrentProcess().Id);
fault.IsIncludedInWatsonSample = true;
}
else
{
fault.IsIncludedInWatsonSample = false;
}
_session.PostEvent(fault);
}
}
public void GetNextDigitalisierungsauftrag_SQL_Server_not_available_returns_service_not_available()
{
// Arrange
var archiveRecord = new ElasticArchiveRecord
{
ProtectionEndDate = new ElasticDateWithYear {
Date = new DateTime(1900, 12, 31), Year = 1900
}
};
// Setup specific exception that signals that database is down
var fe = new FaultEvent <OrderDatabaseNotFoundOrNotRunningException>(new OrderDatabaseNotFoundOrNotRunningException(), new Guid(), null,
new OrderDatabaseNotFoundOrNotRunningException(), null);
var ex = new RequestFaultException("", fe);
var controller = ArrangeControllerForGetNextDigitalisierungsauftragWithDigipoolException(ex, archiveRecord);
// Act
var auftrag = controller.GetNextDigitalisierungsauftrag().GetAwaiter().GetResult();
// Assert
auftrag.Should().BeOfType <NegotiatedContentResult <string> >();
((NegotiatedContentResult <string>)auftrag).StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable);
}
// pretty print a fault statement to the console
internal virtual void dumpFaultLine(FaultEvent e)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// use a slightly different format for ConsoleErrorFaults
if (e is ConsoleErrorFault)
{
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingConsoleError")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(e.information);
}
else
{
String name = e.name();
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingFault")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(name);
if ((string)e.information != null && e.information.length() > 0)
{
sb.Append(TextHelper.GetString("Info.InformationAboutFault")); //$NON-NLS-1$
sb.Append(e.information);
}
if (PluginMain.settingObject.VerboseOutput)
{
sb.AppendLine();
sb.Append(e.stackTrace());
}
}
if (e.isolateId == 1)
{
TraceManager.AddAsync(sb.ToString(), 3);
}
else
{
TraceManager.AddAsync("Worker " + e.isolateId + ": " + sb.ToString(), 3);
}
}
/// <summary>
/// Process events from the queue.
/// Process all events.
/// </summary>
public void ProcessEvents()
{
try
{
if (base.IsDisposed)
{
throw new ObjectDisposedException(GetType().Name, "it is not allowed to process events after channel is disposed");
}
if (scheduler.CanEnterTimedDelegate())
{
TelemetryEvent result;
while (queue.TryDequeue(out result))
{
eventProcessor.ProcessEvent(result);
}
if (!hasProcessedEvents)
{
hasProcessedEvents = true;
initializedAction();
}
}
}
catch (Exception exceptionObject)
{
FaultEvent faultEvent = new FaultEvent("VS/Telemetry/InternalFault", $"Exception in SessionChannel.EventProcessorChannel ProcessEvents Channel = {ChannelId}", exceptionObject)
{
PostThisEventToTelemetry = false
};
faultEvent.AddProcessDump(Process.GetCurrentProcess().Id);
telemetrySession.PostEvent(faultEvent);
}
finally
{
scheduler.ExitTimedDelegate();
}
}
// pretty print a fault statement to the console
internal virtual void dumpFaultLine(FaultEvent e)
{
StringBuilder sb = new StringBuilder();
// use a slightly different format for ConsoleErrorFaults
if (e is ConsoleErrorFault)
{
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingConsoleError")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(e.information);
}
else
{
String name = e.name();
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingFault")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(name);
if ((string)e.information != null && e.information.length() > 0)
{
sb.Append(TextHelper.GetString("Info.InformationAboutFault")); //$NON-NLS-1$
sb.Append(e.information);
}
if (PluginMain.settingObject.VerboseOutput)
{
sb.AppendLine();
sb.Append(e.stackTrace());
}
}
if (e.isolateId == 1)
TraceManager.AddAsync(sb.ToString(), 3);
else
TraceManager.AddAsync("Worker " + e.isolateId + ": " + sb.ToString(), 3);
}
// pretty print a fault statement to the console
internal virtual void dumpFaultLine(FaultEvent e)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// use a slightly different format for ConsoleErrorFaults
if (e is ConsoleErrorFault)
{
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingConsoleError")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(e.information);
}
else
{
String name = e.name();
sb.Append(TextHelper.GetString("Info.LinePrefixWhenDisplayingFault")); //$NON-NLS-1$
sb.Append(' ');
sb.Append(name);
if ((string)e.information != null && e.information.length() > 0)
{
sb.Append(TextHelper.GetString("Info.InformationAboutFault")); //$NON-NLS-1$
sb.Append(e.information);
}
}
TraceManager.AddAsync(sb.ToString(), 3);
}
public void PostEvent(TelemetryEvent telemetryEvent)
{
CodeContract.RequiresArgumentNotNull <TelemetryEvent>(telemetryEvent, "telemetryEvent");
if (!TelemetrySession.IsOptedIn)
{
return;
}
FaultEvent faultEvent = telemetryEvent as FaultEvent;
if (faultEvent == null)
{
throw new InvalidOperationException("WatsonSession channel must have FaultEvent posted");
}
int num = FaultEventWatsonSamplePercent;
faultEvent.ReservedProperties["DataModel.Fault.WatsonSamplePercentDefault"] = FaultEventWatsonSamplePercent;
if (FaultEvent.WatsonSamplePercent.HasValue)
{
num = FaultEvent.WatsonSamplePercent.Value;
faultEvent.ReservedProperties["DataModel.Fault.WatsonSamplePercentOverride"] = FaultEvent.WatsonSamplePercent.Value;
}
if (!faultEvent.IsIncludedInWatsonSample.HasValue)
{
faultEvent.UserOptInToWatson = FaultEvent.FaultEventWatsonOptIn.Unspecified;
if (num > 0)
{
faultEvent.IsIncludedInWatsonSample = (Random.Next(100) < num);
}
else
{
faultEvent.IsIncludedInWatsonSample = false;
}
}
else
{
if (faultEvent.IsIncludedInWatsonSample == true)
{
faultEvent.UserOptInToWatson = FaultEvent.FaultEventWatsonOptIn.PropertyOptIn;
}
else
{
faultEvent.UserOptInToWatson = FaultEvent.FaultEventWatsonOptIn.PropertyOptOut;
}
faultEvent.Properties["VS.Fault.WatsonOptIn"] = faultEvent.UserOptInToWatson.ToString();
}
WatsonReport watsonReport = new WatsonReport(faultEvent, TelemetrySession);
int num2 = FaultEventMaximumWatsonReportsPerSession;
faultEvent.ReservedProperties["DataModel.Fault.MaxReportsPerSessionDefault"] = FaultEventMaximumWatsonReportsPerSession;
if (FaultEvent.MaximumWatsonReportsPerSession.HasValue)
{
num2 = FaultEvent.MaximumWatsonReportsPerSession.Value;
faultEvent.ReservedProperties["DataModel.Fault.MaxReportsPerSessionOverride"] = FaultEventMaximumWatsonReportsPerSession;
}
if (num == 0 && num2 == 0)
{
faultEvent.IsIncludedInWatsonSample = false;
}
int minSecondsBetweenReports = FaultEventMinimumSecondsBetweenWatsonReports;
faultEvent.ReservedProperties["DataModel.Fault.MinSecondsBetweenReportsDefault"] = FaultEventMinimumSecondsBetweenWatsonReports;
if (FaultEvent.MinimumSecondsBetweenWatsonReports.HasValue)
{
minSecondsBetweenReports = FaultEvent.MinimumSecondsBetweenWatsonReports.Value;
faultEvent.ReservedProperties["DataModel.Fault.MinSecondsBetweenReportsOverride"] = FaultEvent.MinimumSecondsBetweenWatsonReports;
}
watsonReport.PostWatsonReport(num2, minSecondsBetweenReports);
}