public virtual string ComputeFailureHash(Exception failureException)
{
string result;
WatsonExceptionReport.TryStringHashFromStackTrace(failureException, false, out result);
return(result);
}
protected override void WriteSpecializedPartOfTextReport(TextWriter reportFile)
{
base.WriteReportFileHeader(reportFile, "CLR is " + (base.IsFlagSet(ReportOptions.ReportTerminateAfterSend) ? string.Empty : "not ") + "terminating");
reportFile.WriteLine("P1(flavor)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.Flavor));
reportFile.WriteLine("P2(appVersion)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AppVersion));
reportFile.WriteLine("P3(appName)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AppName));
reportFile.WriteLine("P4(assemblyName)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyName));
reportFile.WriteLine("P5(exMethodName)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExMethodName));
reportFile.WriteLine("P6(exceptionType)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExceptionType));
reportFile.WriteLine("P7(callstackHash)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.CallstackHash));
reportFile.WriteLine("P8(assemblyVer)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyVer));
reportFile.WriteLine();
reportFile.WriteLine("Exchange Version={0}", WatsonReport.ExchangeFormattedVersion(ExWatson.ExchangeVersion));
reportFile.WriteLine("Default Assembly Version={0}", WatsonReport.ExchangeFormattedVersion(ExWatson.DefaultAssemblyVersion));
reportFile.WriteLine("Executable Name={0}", WatsonReport.GetValidString(ExWatson.RealAppName));
reportFile.WriteLine("Executable Version={0}", WatsonReport.ExchangeFormattedVersion(ExWatson.RealApplicationVersion));
reportFile.WriteLine("Base Exception Target Site={0}", this.baseExceptionTargetSite);
reportFile.WriteLine("Base Exception Assembly name={0}", this.baseExceptionAssemblyName);
reportFile.WriteLine("Base Exception Method Name={0}", this.baseExceptionMethodName);
reportFile.WriteLine("Exception Message={0}", this.exception.Message);
reportFile.WriteLine("EIP=0x{0}", (IntPtr.Size == 4) ? this.exceptionEIP.ToString("x8") : this.exceptionEIP.ToString("x16"));
reportFile.WriteLine("Build bit-size={0}", IntPtr.Size * 8);
WatsonExceptionReport.WriteReportFileLIDs(reportFile, this.lids);
WatsonExceptionReport.WriteReportFileExceptionObjectInfo(reportFile, this.exception);
WatsonExceptionReport.WriteReportFileInnerExceptionObjectsInfo(reportFile, this.exception);
WatsonExceptionReport.WriteReportFileStackTrace(reportFile, this.exception);
WatsonExceptionReport.WriteReportFileLIDs(reportFile, this.lids);
WatsonExceptionReport.WriteReportFileInnerExceptionObjectsInfo(reportFile, this.exception);
}
protected override void AddExtraFiles(WerSafeHandle watsonReportHandle)
{
if (base.ReportingAllowed && !base.ProcessHandle.IsInvalid && !base.IsFlagSet(ReportOptions.DoNotCollectDumps))
{
if (WatsonExceptionReport.beforeDumpCollectionAction != null)
{
WatsonExceptionReport.beforeDumpCollectionAction();
}
DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS wer_DUMP_CUSTOM_OPTIONS = new DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS();
wer_DUMP_CUSTOM_OPTIONS.size = Marshal.SizeOf(typeof(DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS));
wer_DUMP_CUSTOM_OPTIONS.mask = DiagnosticsNativeMethods.WER_DUMP_FLAGS.WER_DUMP_MASK_DUMPTYPE;
wer_DUMP_CUSTOM_OPTIONS.dumpFlags = (DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithDataSegs | DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithHandleData | DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithUnloadedModules | DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithProcessThreadData | DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithPrivateReadWriteMemory);
DiagnosticsNativeMethods.WerReportAddDump(watsonReportHandle, base.ProcessHandle, IntPtr.Zero, DiagnosticsNativeMethods.WER_DUMP_TYPE.WerDumpTypeMiniDump, this.exceptionInfo, wer_DUMP_CUSTOM_OPTIONS, 0U);
DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS wer_DUMP_CUSTOM_OPTIONS2 = new DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS();
wer_DUMP_CUSTOM_OPTIONS2.size = Marshal.SizeOf(typeof(DiagnosticsNativeMethods.WER_DUMP_CUSTOM_OPTIONS));
wer_DUMP_CUSTOM_OPTIONS2.mask = DiagnosticsNativeMethods.WER_DUMP_FLAGS.WER_DUMP_MASK_DUMPTYPE;
wer_DUMP_CUSTOM_OPTIONS2.dumpFlags = (wer_DUMP_CUSTOM_OPTIONS.dumpFlags | DiagnosticsNativeMethods.MINIDUMP_TYPE.MiniDumpWithFullMemory);
DiagnosticsNativeMethods.WerReportAddDump(watsonReportHandle, base.ProcessHandle, IntPtr.Zero, DiagnosticsNativeMethods.WER_DUMP_TYPE.WerDumpTypeHeapDump, this.exceptionInfo, wer_DUMP_CUSTOM_OPTIONS2, 0U);
}
}
protected override void PrepareBucketingParameters()
{
Exception baseException = null;
string s = null;
string text = null;
string text2 = null;
string text3 = null;
Version v = null;
int num = 0;
int num2 = 0;
string text4 = null;
if (this.exception != null)
{
text2 = this.exception.GetType().ToString();
WatsonExceptionReport.TryStringHashFromStackTrace(this.exception, base.IsFlagSet(ReportOptions.DeepStackTraceHash), out text3);
baseException = this.exception.GetBaseException();
try
{
string text5 = (baseException == null) ? null : baseException.StackTrace;
if (!string.IsNullOrEmpty(text5))
{
MatchCollection matchCollection = WatsonExceptionReport.regexFunctions.Matches(text5);
foreach (object obj in matchCollection)
{
Match match = (Match)obj;
if (match.Groups.Count == 2)
{
if (text == null)
{
text = match.Groups[1].Value;
}
if (match.Groups[1].Value.Contains("Microsoft."))
{
text = match.Groups[1].Value;
if (text.IndexOf("throw", StringComparison.OrdinalIgnoreCase) <= 0 && text.IndexOf("failfast", StringComparison.OrdinalIgnoreCase) <= 0 && text.IndexOf("assert", StringComparison.OrdinalIgnoreCase) <= 0 && text.IndexOf("error", StringComparison.OrdinalIgnoreCase) <= 0)
{
break;
}
}
}
}
}
if (text != null)
{
string text6 = text;
try
{
int num3 = text.LastIndexOf(Type.Delimiter + ".");
if (num3 < 0)
{
num3 = text.LastIndexOf(Type.Delimiter);
}
text6 = text.Substring(0, num3);
}
catch
{
}
Type type = Type.GetType(text6);
if (type == null)
{
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
type = assembly.GetType(text6);
if (type != null)
{
break;
}
}
}
if (type != null)
{
if (WatsonReport.IsAssemblyDynamic(type.Assembly))
{
s = "[Dynamic Assembly]";
v = new Version(0, 0, 0, 0);
}
else
{
try
{
s = Path.GetFileName(type.Assembly.Location);
}
catch
{
}
try
{
object[] customAttributes = type.Assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false);
if (customAttributes.Length == 1)
{
AssemblyFileVersionAttribute assemblyFileVersionAttribute = customAttributes[0] as AssemblyFileVersionAttribute;
if (assemblyFileVersionAttribute != null)
{
v = new Version(assemblyFileVersionAttribute.Version);
}
}
}
catch
{
}
}
}
}
PropertyInfo propertyInfo = (baseException == null) ? null : baseException.GetType().GetProperty("DiagCtx");
if (propertyInfo != null)
{
MethodInfo getMethod = propertyInfo.GetGetMethod();
object obj2 = getMethod.Invoke(baseException, null);
this.lids = obj2.ToString();
MatchCollection matchCollection2 = WatsonExceptionReport.regexLids.Matches(this.lids);
foreach (object obj3 in matchCollection2)
{
Match match2 = (Match)obj3;
if (match2.Groups.Count >= 2)
{
string value = match2.Groups[0].Value;
num = WatsonReport.ComputeHash(value, num);
num2 = Convert.ToInt32(match2.Groups[1].Value);
if (match2.Groups.Count == 4)
{
text4 = match2.Groups[3].Value;
}
}
}
num &= 65535;
}
if (ExWatson.MsInternal)
{
base.CrashDetails = WatsonReport.GetValidString(this.GetExWatsonCrashDetailsString());
}
}
catch
{
}
}
if (baseException != null && baseException.TargetSite != null)
{
this.baseExceptionTargetSite = base.EvaluateOrDefault <string>(delegate
{
RuntimeMethodHandle methodHandle = baseException.TargetSite.MethodHandle;
IntPtr value2 = baseException.TargetSite.MethodHandle.Value;
return(baseException.TargetSite.MethodHandle.Value.ToString());
}, "unknown");
this.baseExceptionAssemblyName = base.EvaluateOrDefault <string>(delegate
{
if (baseException.TargetSite.Module == null)
{
return("unknown");
}
return(baseException.TargetSite.Module.Name ?? "unknown");
}, "unknown");
this.baseExceptionMethodName = base.EvaluateOrDefault <string>(delegate
{
string text7 = null;
if (baseException.TargetSite.ReflectedType != null)
{
text7 = baseException.TargetSite.ReflectedType.FullName;
}
string name = baseException.TargetSite.Name;
if (text7 == null || name == null)
{
return("unknown");
}
return(text7 + "." + name);
}, "unknown");
}
else
{
this.baseExceptionTargetSite = "unknown";
this.baseExceptionAssemblyName = "unknown";
this.baseExceptionMethodName = "unknown";
}
try
{
if (this.lids != null)
{
text3 = text3 + "-" + Convert.ToString(num, 16);
this.baseExceptionAssemblyName = this.baseExceptionAssemblyName + "-" + num2;
if (text4 != null)
{
text2 = text2 + "-" + text4;
}
}
}
catch
{
}
base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExceptionType, WatsonReport.GetValidString(text2));
base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyName, WatsonReport.GetValidString(s));
base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyVer, WatsonReport.ExchangeFormattedVersion(v));
base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExMethodName, WatsonReport.GetValidString(text));
base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.CallstackHash, WatsonReport.GetValidString(text3));
}
