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); }
public override string Evaluate(WatsonReport watsonReport) { string text = base.Expression + "=" + Environment.GetEnvironmentVariable(base.Expression); watsonReport.LogExtraData(text); return(text); }
protected override void WriteReportTypeSpecificSection(XmlWriter reportFile) { using (new SafeXmlTag(reportFile, "exception-report").WithAttribute("is-clr-terminating", base.IsFlagSet(ReportOptions.ReportTerminateAfterSend) ? "1" : "0")) { using (new SafeXmlTag(reportFile, "application").WithAttribute("name", base.AppName).WithAttribute("version", WatsonReport.ExchangeFormattedVersion(base.AppVersion))) { } using (new SafeXmlTag(reportFile, "assembly").WithAttribute("name", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyName)).WithAttribute("version", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyVer))) { } using (SafeXmlTag safeXmlTag4 = new SafeXmlTag(reportFile, "exception")) { safeXmlTag4.SetContent(WatsonReport.SanitizeException(this.exception.ToString())); } using (new SafeXmlTag(reportFile, "base-exception").WithAttribute("target-site", this.baseExceptionTargetSite).WithAttribute("assembly-name", this.baseExceptionAssemblyName).WithAttribute("method-name", this.baseExceptionMethodName)) { } using (SafeXmlTag safeXmlTag6 = new SafeXmlTag(reportFile, "process").WithAttribute("eip", "0x" + ((IntPtr.Size == 4) ? this.exceptionEIP.ToString("x8") : this.exceptionEIP.ToString("x16"))).WithAttribute("bitness", (IntPtr.Size * 8).ToString()).WithAttribute("pid", base.ProcessId.ToString())) { if (base.ProcessId == DiagnosticsNativeMethods.GetCurrentProcessId()) { safeXmlTag6.WithAttribute("managed-tid", Environment.CurrentManagedThreadId.ToString()).WithAttribute("native-tid", DiagnosticsNativeMethods.GetCurrentThreadId().ToString()); } } if (this.lids != null) { using (SafeXmlTag safeXmlTag7 = new SafeXmlTag(reportFile, "location-ids")) { safeXmlTag7.SetContent(this.lids); } } } }
private void SetWatsonMethodNameFromStackTrace() { int num = 0; string arg = string.Empty; string arg2 = string.Empty; StackFrame frame; MethodBase method; for (;;) { frame = this.stackTrace.GetFrame(num); method = frame.GetMethod(); string name = method.Name; if (name.IndexOf("log", StringComparison.OrdinalIgnoreCase) >= 0) { break; } num++; if (num >= this.stackTrace.FrameCount) { return; } } num += 2; frame = this.stackTrace.GetFrame(num); method = frame.GetMethod(); arg = method.Name; arg2 = WatsonReport.GetShortParameter(method.DeclaringType.FullName); this.watsonMethodName = arg2 + '.' + arg; }
protected override string GetShortParameter(uint bucketParamId, string longParameter) { if (bucketParamId == 4U && Uri.IsWellFormedUriString(longParameter, UriKind.RelativeOrAbsolute)) { return(longParameter.Trim()); } return(WatsonReport.GetShortParameter(longParameter.Trim())); }
protected override void WriteSpecializedPartOfTextReport(TextWriter reportFile) { base.WriteReportFileHeader(reportFile, "Manifest Report"); reportFile.WriteLine("P0(appVersion)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AppVersion))); reportFile.WriteLine("P1(appName)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AppName))); reportFile.WriteLine("P2(exMethodName)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExMethodName))); reportFile.WriteLine("P3(exceptionType)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExceptionType))); reportFile.WriteLine("P4(callstackHash)={0}", base.BucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.CallstackHash)); WatsonExternalProcessReport.WriteReportFileCallStack(reportFile, this.callstack); WatsonExternalProcessReport.WriteReportFileDetailedExceptionInformation(reportFile, this.detailedExceptionInformation); }
protected static void WriteReportFileExceptionObjectInfo(TextWriter reportFile, Exception exceptionObject) { if (exceptionObject != null) { reportFile.WriteLine(reportFile.NewLine); reportFile.WriteLine("----------------------------------------------------"); reportFile.WriteLine("------------ exceptionObject.ToString() ------------"); reportFile.WriteLine("----------------------------------------------------"); reportFile.WriteLine(WatsonReport.SanitizeException(exceptionObject.ToString())); } }
protected static void WriteReportFileInnerExceptionObjectsInfo(TextWriter reportFile, Exception exception) { if (exception != null) { for (Exception innerException = exception.InnerException; innerException != null; innerException = innerException.InnerException) { reportFile.WriteLine(reportFile.NewLine); reportFile.WriteLine("-------- exception.InnerException.ToString() -------"); reportFile.WriteLine(WatsonReport.SanitizeException(innerException.ToString())); } } }
internal static string[] BuildWatsonParameters(string flavor, string version, string traceComponent, string functionName, string exceptionType, string callstack, int callStackHash) { return(new string[] { WatsonReport.GetValidString(flavor), WatsonReport.GetValidString(version), "OWAClient", WatsonReport.GetValidString(traceComponent), WatsonReport.GetValidString(functionName), WatsonReport.GetValidString(exceptionType), WatsonClientReport.GetStringHashFromString(callStackHash) }); }
protected static void WriteReportFileStackTrace(TextWriter reportFile, Exception exception) { if (exception != null) { reportFile.WriteLine(reportFile.NewLine); reportFile.WriteLine("----------------------------------------------------"); reportFile.WriteLine("--------------- exception.StackTrace ---------------"); reportFile.WriteLine("----------------------------------------------------"); if (exception.StackTrace != null) { reportFile.WriteLine(WatsonReport.SanitizeException(exception.StackTrace)); } } }
public override string Evaluate(WatsonReport watsonReport) { string text = string.Concat(new string[] { "--- ", base.Expression, " ---\r\n", WatsonWmiQueryReportAction.EvaluateWmiQuery(base.Expression), "--- END ---" }); watsonReport.LogExtraData(text); return(text); }
protected override void WriteSpecializedPartOfTextReport(TextWriter reportFile) { base.WriteReportFileHeader(reportFile, "Manifest Report: Non Fatal Error for OWA"); reportFile.WriteLine("P1(flavor)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.Flavor))); reportFile.WriteLine("P2(exVersion)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.ExVersion))); reportFile.WriteLine("P3(appName)={0}", "OWAClient"); reportFile.WriteLine("P4(traceComponent)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.TraceComponent))); reportFile.WriteLine("P5(function)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.Function))); reportFile.WriteLine("P6(exceptionType)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.ExceptionType))); reportFile.WriteLine("P7(callstackHash)={0}", base.BucketingParameter <WatsonClientReport.BucketParamId>(WatsonClientReport.BucketParamId.CallstackHash)); reportFile.WriteLine("filename={0}", WatsonReport.GetValidString(this.fileName)); WatsonClientReport.WriteReportFileClientCallStack(reportFile, this.ReportCallStack); WatsonClientReport.WriteReportFileClientDetailedExceptionInformation(reportFile, this.DetailedExceptionInformation); }
public override string Evaluate(WatsonReport watsonReport) { string registryValue = WatsonRegKeyReportAction.GetRegistryValue(base.Expression); string text; if (registryValue == null) { text = base.Expression + " not found."; } else { text = base.Expression + "=" + registryValue; } watsonReport.LogExtraData(text); return(text); }
protected override void WriteSpecializedPartOfTextReport(TextWriter reportFile) { base.WriteReportFileHeader(reportFile, "Manifest Report"); reportFile.WriteLine("P1(flavor)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.Flavor))); reportFile.WriteLine("P2(appVersion)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AppVersion))); reportFile.WriteLine("P3(appName)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AppName))); reportFile.WriteLine("P4(assemblyName)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AssemblyName))); reportFile.WriteLine("P5(exMethodName)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.ExMethodName))); reportFile.WriteLine("P6(exceptionType)={0}", WatsonReport.GetValidString(base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.ExceptionType))); reportFile.WriteLine("P7(callstackHash)={0}", base.BucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.CallstackHash)); reportFile.WriteLine("P8(assemblyVer)={0}", WatsonReport.GetValidString(this.assemblyVersion)); WatsonGenericReport.WriteReportFileCallStack(reportFile, this.callstack); if (!string.IsNullOrEmpty(this.detailedExceptionInformation)) { WatsonGenericReport.WriteReportFileDetailedExceptionInformation(reportFile, this.detailedExceptionInformation); } }
protected override void PrepareBucketingParameters() { base.PrepareBucketingParameters(); try { this.appVersion = WatsonReport.ExchangeFormattedVersion(new Version(this.appVersion)); } catch { this.appVersion = WatsonReport.ExchangeFormattedVersion(ExWatson.ApplicationVersion); } base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AppVersion, this.appVersion); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AppName, this.appName); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AssemblyName, this.assemblyName); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.ExMethodName, this.methodName); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.ExceptionType, this.exceptionType); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.CallstackHash, this.callstackHash); base.SetBucketingParameter <WatsonReport.BucketParamId>(WatsonReport.BucketParamId.AssemblyVer, this.assemblyVersion); }
internal static string StringHashFromStackTrace(string stackTrace) { int num = 0; string result = "0"; try { int num2 = 0; int num3 = 0; MatchCollection matchCollection = WatsonGenericReport.RegexFunctions.Matches(stackTrace); foreach (object obj in matchCollection) { Match match = (Match)obj; if (match.Groups.Count == 2) { string value = match.Groups[1].Value; if (num == 0) { num3 = WatsonReport.ComputeHash(value, num3); } if (!value.Contains("Microsoft")) { continue; } num++; num2 = WatsonReport.ComputeHash(value, num2); } if (num >= 10) { break; } } if (num == 0) { num2 = num3; } result = Convert.ToString(num2 & 65535, 16); } catch { } return(result); }
public override string Evaluate(WatsonReport watsonReport) { string result; try { watsonReport.PerformWerOperation(delegate(WerSafeHandle reportHandle) { DiagnosticsNativeMethods.WerReportAddFile(reportHandle, base.Expression, DiagnosticsNativeMethods.WER_FILE_TYPE.WerFileTypeOther, (DiagnosticsNativeMethods.WER_FILE_FLAGS) 0U); }); watsonReport.LogExtraFile(base.Expression); result = "Attached file \"" + Path.GetFileName(base.Expression) + "\" to report."; } catch (Exception ex) { watsonReport.LogExtraFile(this.FormatError(base.Expression, ex)); result = this.FormatError(base.Expression, ex); } return(result); }
internal void WriteResult(WatsonReport watsonReport, XmlWriter writer) { using (SafeXmlTag safeXmlTag = new SafeXmlTag(writer, "action").WithAttribute("type", this.ActionName)) { try { safeXmlTag.SetContent(this.Evaluate(watsonReport)); } catch (Exception ex) { watsonReport.RecordExceptionWhileCreatingReport(ex); safeXmlTag.SetContent(string.Concat(new string[] { "Exception thrown while evaluating action \"", this.ActionName, "\" (expression: ", this.Expression, "):\r\n", ex.ToString() })); } } }
public abstract string Evaluate(WatsonReport watsonReport);
public void UpdateHash(ref int hash) { hash = WatsonReport.ComputeHash(this.SanitizedFunctionName, hash); hash = WatsonReport.ComputeHash(this.FileName, hash); }
public WatsonLatencyReport(string eventType, string triggerVersion, string locationIdentity, string exceptionName, string callstack, string methodName, string detailedExceptionInformation) : base(eventType, WatsonReport.GetValidString(triggerVersion), ExWatson.AppName, WatsonReport.ExchangeFormattedVersion(ExWatson.ApplicationVersion), WatsonReport.GetValidString(locationIdentity), WatsonReport.GetValidString(exceptionName), WatsonReport.GetValidString(callstack), WatsonGenericReport.StringHashFromStackTrace(WatsonReport.GetValidString(callstack)), WatsonReport.GetValidString(methodName), detailedExceptionInformation) { }
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); }
public override string Evaluate(WatsonReport watsonReport) { watsonReport.LogExtraData(base.Expression); return(base.Expression); }
internal WatsonTroubleshootingReport(string eventType, string triggerVersion, string locationIdentity, string exceptionName, string callstack, string methodName, string detailedExceptionInformation, string traceFileName) : base(eventType, WatsonReport.GetValidString(triggerVersion), ExWatson.AppName, WatsonReport.ExchangeFormattedVersion(ExWatson.ApplicationVersion), WatsonReport.GetValidString(locationIdentity), WatsonReport.GetValidString(exceptionName), WatsonReport.GetValidString(callstack), WatsonGenericReport.StringHashFromStackTrace(WatsonReport.GetValidString(callstack)), WatsonReport.GetValidString(methodName), detailedExceptionInformation) { this.traceFileName = traceFileName; }
internal static bool TryStringHashFromStackTrace(Exception exception, bool deep, out string stringHash) { bool result = false; int num = deep ? 50 : 10; stringHash = "0"; try { int num2 = 0; int num3 = 0; int num4 = 0; while (exception != null) { string stackTrace = exception.StackTrace; if (!string.IsNullOrEmpty(exception.StackTrace)) { MatchCollection matchCollection = WatsonExceptionReport.regexFunctions.Matches(stackTrace); foreach (object obj in matchCollection) { Match match = (Match)obj; if (match.Groups.Count == 2) { string value = match.Groups[1].Value; if (num3 == 0) { num4 = WatsonReport.ComputeHash(value, num4); } if (!value.Contains("Microsoft")) { continue; } num3++; num2 = WatsonReport.ComputeHash(value, num2); } if (num3 >= num) { break; } } if (exception is SerializationException) { Match match2 = WatsonExceptionReport.regexSerialization.Match(exception.Message); while (match2.Success) { string value2 = match2.Groups[1].Value; num2 = WatsonReport.ComputeHash(value2, num2); match2 = match2.NextMatch(); } } } exception = exception.InnerException; } if (num3 == 0) { num2 = num4; } stringHash = Convert.ToString(num2 & 65535, 16); result = true; } catch { } return(result); }
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)); }
protected override void PrepareBucketingParameters() { string s = "unknown"; if (base.Exception != null) { s = base.Exception.GetType().ToString(); } base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExceptionType, WatsonReport.GetValidString(s)); base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyName, "unknown"); base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.AssemblyVer, "unknown"); base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.ExMethodName, "unknown"); base.SetBucketingParameter <WatsonExceptionReport.BucketParamId>(WatsonExceptionReport.BucketParamId.CallstackHash, "0"); }