public void ScriptResultsAddedNullScriptData() { IBugTrackerV1Control plugInControl = new FaultDatabaseControl(); Assert.AreNotEqual(null, plugInControl); IBugTrackerV1Context context = plugInControl.CreateContext(); Assert.AreNotEqual(null, context); Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl)); BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568); BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567); BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection()); theEvent.Signature["Exception"] = "0x23434"; BugTrackerCab cab = new BugTrackerCab(12243, 12121, false, true, new NameValueCollection(), "c:\\test\\my.cab"); cab.AnalysisData["New1"] = "Data1"; cab.AnalysisData["New2"] = "Data2"; BugTrackerScriptResult result = new BugTrackerScriptResult("ScriptName", 1, DateTime.Now, DateTime.Now, null); context.DebugScriptExecuted(BugTrackerReportType.Automatic, product, file, theEvent, cab, result); plugInControl.ReleaseContext(context); Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl)); }
public void EventToString() { NameValueCollection signature = new NameValueCollection(); signature.Add("Exception", "0x123456"); signature.Add("Offset", "0x123457"); BugTrackerEvent theEvent = new BugTrackerEvent("Bug 1234", "Plugin bug ref", 12345678, "CLR20 32-Bit", 10000, signature); String result = theEvent.ToString(); Assert.AreEqual("Event: Id=12345678, EventTypeName=CLR20 32-Bit, BugReference=Bug 1234, TotalHits=10000\r\n Exception=0x123456\r\n Offset=0x123457\r\n", result); }
/// <summary> /// Process a cab note table update. This may indicate a new item or the change to an existing item. /// </summary> private bool processCabNoteUpdate(StackHashBugTrackerUpdate update) { // Get the associated product and file information. StackHashProduct product = m_Index.GetProduct((int)update.ProductId); StackHashFile file = m_Index.GetFile(product, (int)update.FileId); StackHashEvent theEvent = m_Index.GetEvent(product, file, new StackHashEvent((int)update.EventId, update.EventTypeName)); StackHashCab cab = m_Index.GetCab(product, file, theEvent, (int)update.CabId); StackHashNoteEntry note = m_Index.GetCabNote((int)update.ChangedObjectId); if ((product == null) || (file == null) || (theEvent == null) || (cab == null) || (note == null)) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Cab Note: Inconsistent Update Table Entry"); return(false); } BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id); BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id); NameValueCollection eventSignature = new NameValueCollection(); foreach (StackHashParameter param in theEvent.EventSignature.Parameters) { eventSignature.Add(param.Name, param.Value); } BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); NameValueCollection analysis = new NameValueCollection(); analysis.Add("DotNetVersion", cab.DumpAnalysis.DotNetVersion); analysis.Add("MachineArchitecture", cab.DumpAnalysis.MachineArchitecture); analysis.Add("OSVersion", cab.DumpAnalysis.OSVersion); analysis.Add("ProcessUpTime", cab.DumpAnalysis.ProcessUpTime); analysis.Add("SystemUpTime", cab.DumpAnalysis.SystemUpTime); String cabFileName = m_Index.GetCabFileName(product, file, theEvent, cab); BugTrackerCab btCab = new BugTrackerCab(cab.Id, cab.SizeInBytes, cab.CabDownloaded, cab.Purged, analysis, cabFileName); BugTrackerNote btCabNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note); String newBugId = null; if (update.TypeOfChange == StackHashChangeType.NewEntry) { newBugId = m_TaskParameters.PlugInContext.CabNoteAdded(null, BugTrackerReportType.Automatic, btProduct, btFile, btEvent, btCab, btCabNote); } setPlugInBugReference(product, file, theEvent, newBugId); return(true); }
public void EventAddedNoEventSignature() { IBugTrackerV1Control plugInControl = new FaultDatabaseControl(); Assert.AreNotEqual(null, plugInControl); IBugTrackerV1Context context = plugInControl.CreateContext(); Assert.AreNotEqual(null, context); Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl)); BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568); BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567); BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection()); context.EventAdded(BugTrackerReportType.Automatic, product, file, theEvent); plugInControl.ReleaseContext(context); Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl)); }
/// <summary> /// Process an event note table update. This may indicate a new item or the change to an existing item. /// </summary> private bool processEventNoteUpdate(StackHashBugTrackerUpdate update) { // Get the associated product and file information. StackHashProduct product = m_Index.GetProduct((int)update.ProductId); StackHashFile file = m_Index.GetFile(product, (int)update.FileId); StackHashEvent theEvent = m_Index.GetEvent(product, file, new StackHashEvent((int)update.EventId, update.EventTypeName)); StackHashNoteEntry note = m_Index.GetEventNote((int)update.ChangedObjectId); if ((product == null) || (file == null) || (theEvent == null) || (note == null)) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Event Note: Inconsistent Update Table Entry"); return(false); } BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id); BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id); NameValueCollection eventSignature = new NameValueCollection(); foreach (StackHashParameter param in theEvent.EventSignature.Parameters) { eventSignature.Add(param.Name, param.Value); } BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); BugTrackerNote btEventNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note); String newBugId = null; if (update.TypeOfChange == StackHashChangeType.NewEntry) { newBugId = m_TaskParameters.PlugInContext.EventNoteAdded(null, BugTrackerReportType.Automatic, btProduct, btFile, btEvent, btEventNote); } setPlugInBugReference(product, file, theEvent, newBugId); return(true); }
public void EventNoteAdded() { IBugTrackerV1Control plugInControl = new FaultDatabaseControl(); Assert.AreNotEqual(null, plugInControl); IBugTrackerV1Context context = plugInControl.CreateContext(); Assert.AreNotEqual(null, context); Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl)); BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568); BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567); BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection()); theEvent.Signature["Exception"] = "0x23434"; BugTrackerNote note = new BugTrackerNote(DateTime.Now, "Source", "MarkJ", "Hello from me"); context.EventNoteAdded(BugTrackerReportType.Automatic, product, file, theEvent, note); plugInControl.ReleaseContext(context); Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl)); }
/// <summary> /// This method is called when the processing of an Event has completed. Events have associated Cabs, Scripts and notes which /// may all be reported during a MANUAL Bug Report. This call effectively delimits the reporting of all /// information associated with an event so, if desired, the plug-in can gather all of the information together in one /// go for sending to the fault database. This may improve performance for events with large amounts of stored data. /// /// The plug-in may thus see... /// EventAdded /// EventNoteAdded, EventNoteAdded,... /// CabAdded, CabAdded,... /// CabNoteAdded, CabNoteAdded,... /// ScriptResultAdded, ScriptResultAdded,... /// EventManualUpdateCompleted. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event whose details have now been reported.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent) { if (m_disposed) { throw new ObjectDisposedException("EmailPluginContext"); } if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } // Don't change the plugin bug reference. Setting this to any other value will update the plugin bug reference in the // StackHash database. String pluginBugReference = null; return(pluginBugReference); }
/// <summary> /// If the report type is automatic then this call indicates that an Event note has been added to the /// StackHash database by a StackHash client. /// /// If the report type is manual then this call indicates that an Event note already exists in the /// StackHash database. This is the result of a BugReport task being run. /// /// Note that it is possible that the event note existence has already been reported, so the /// code here should check, if necessary, that this is not a duplicate before creating new items in /// the destination bug tracking system. /// /// Important Note: AN EVENT IS IDENTIFIED BY ITS ID AND EVENTTYPENAME TOGETHER. Therefore it is possible to /// have events with the same ID but different EventTypeName. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event to which the note belongs.</param> /// <param name="note">The event note to add.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string EventNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerNote note) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (note == null) { throw new ArgumentNullException("note"); } // Note that all of the interface objects have a built in ToString() which formats the fields suitably. BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Event Note Added: " + note.ToString()); // Don't change the bug reference. return(null); }
private StackHashEvent processCab(StackHashBugReportData request, StackHashProduct product, StackHashFile file, StackHashEvent theEvent, StackHashCab cab, BugTrackerProduct btProduct, BugTrackerFile btFile, BugTrackerEvent btEvent) { if (this.CurrentTaskState.AbortRequested) { throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins"); } NameValueCollection analysis = new NameValueCollection(); analysis.Add("DotNetVersion", cab.DumpAnalysis.DotNetVersion); analysis.Add("MachineArchitecture", cab.DumpAnalysis.MachineArchitecture); analysis.Add("OSVersion", cab.DumpAnalysis.OSVersion); analysis.Add("ProcessUpTime", cab.DumpAnalysis.ProcessUpTime); analysis.Add("SystemUpTime", cab.DumpAnalysis.SystemUpTime); String cabFileName = m_Index.GetCabFileName(product, file, theEvent, cab); BugTrackerCab btCab = new BugTrackerCab(cab.Id, cab.SizeInBytes, cab.CabDownloaded, cab.Purged, analysis, cabFileName); if (((request.Options & StackHashReportOptions.IncludeCabs) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { String newBugId = m_TaskParameters.PlugInContext.CabAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent, btCab); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, btEvent.Signature); } if (((request.Options & StackHashReportOptions.IncludeCabNotes) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { StackHashNotes notes = m_Index.GetCabNotes(product, file, theEvent, cab); foreach (StackHashNoteEntry note in notes) { if (this.CurrentTaskState.AbortRequested) { throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins"); } BugTrackerNote btEventNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note); String newBugId = m_TaskParameters.PlugInContext.CabNoteAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent, btCab, btEventNote); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, btEvent.Signature); } } if (((request.Options & StackHashReportOptions.IncludeScriptResults) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { StackHashScriptResultFiles scriptResults = m_TaskParameters.TheScriptResultsManager.GetResultFiles(product, file, theEvent, cab); foreach (StackHashScriptResultFile scriptResultFile in scriptResults) { if (this.CurrentTaskState.AbortRequested) { throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins"); } try { StackHashScriptResult scriptResult = m_TaskParameters.TheScriptResultsManager.GetResultFileData(product, file, theEvent, cab, scriptResultFile.ScriptName); if (scriptResult != null) { BugTrackerScriptResult btScriptResult = new BugTrackerScriptResult(scriptResult.Name, scriptResult.ScriptVersion, scriptResult.LastModifiedDate, scriptResult.RunDate, scriptResult.ToString()); String newBugId = m_TaskParameters.PlugInContext.DebugScriptExecuted(m_PlugIns, m_ReportType, btProduct, btFile, btEvent, btCab, btScriptResult); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, btEvent.Signature); } } catch (System.Exception ex) { DiagnosticsHelper.LogException(DiagSeverity.Information, "Failed to load script file for reporting " + cab.Id.ToString(CultureInfo.InvariantCulture) + " " + scriptResultFile.ScriptName, ex); } } } return(theEvent); }
public string EventNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerNote note) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (note == null) { throw new ArgumentNullException("note"); } m_LastEventNote = note.Note; BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Note Added: " + note.ToString()); // If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should // also contain the bug reference. if (m_Properties["SetBugId"] == "True") { if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture)) { throw new ArgumentException("Bug ref not set", "theEvent"); } } m_EventNoteAddedCount++; return(null); }
public string EventAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } m_EventAddedCount++; String bugId = theEvent.BugReference; if (m_Properties["SetBugId"] == "True") { bugId = "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Added: " + theEvent.ToString()); return(bugId); }
public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Manual Update Completed: " + theEvent.ToString()); m_EventCompleteCount++; return(theEvent.BugReference); }
/// <summary> /// If the report type is automatic then this call indicates that a Debug Script Result has been added to the /// StackHash database by way the Cab Analysis task running or the StackHash client manually running a script /// on a cab. /// /// If the report type is manual then this call indicates that an Debug Script Result already exists in the /// StackHash database. This is the result of a BugReport task being run. /// /// scriptResult.ToString() can be used to format the string for addition to a Fault Database system. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event to which the cab belongs.</param> /// <param name="cab">The cab to which the debug script result belongs.</param> /// <param name="scriptResult">The result of running a debug script on the cab dump file.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string DebugScriptExecuted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerScriptResult scriptResult) { return(null); }
/// <summary> /// If the report type is automatic then this call indicates that a Cab Note has been added to the /// StackHash database by way of the StackHash user adding one. /// /// If the report type is manual then this call indicates that an Cab Note already exists in the /// StackHash database. This is the result of a BugReport task being run. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event to which the cab belongs.</param> /// <param name="cab">The cab to which the note belongs.</param> /// <param name="note">The cab note to add.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string CabNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerNote note) { return(null); }
/// <summary> /// If the report type is automatic then this call indicates that a Cab has been updated in the /// StackHash database by way of: a Synchronize with the WinQual web site; downloading a cab manually from the /// StackHash client; or a script providing further diagnostic information. /// /// This method is not currently called during a manual BugReport. /// /// A Cab entry indicates that a cab is available on the WinQual site. The cab has not necessarily been /// downloaded yet. Once the cab is downloaded, the CabUpdated method will be called with Cab.CabDownloaded == true. /// /// Cabs are associated with particular events (identified by EventId, EventTypeName). /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event to which the cab belongs.</param> /// <param name="cab">The cab being added.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string CabUpdated(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab) { return(null); }
public string CabAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (cab == null) { throw new ArgumentNullException("cab"); } if (cab.CabPathAndFileName == null) { throw new ArgumentException("Cab path is null", "cab"); } BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Cab Added: " + cab.ToString()); // If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should // also contain the bug reference. if (m_Properties["SetBugId"] == "True") { if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture)) { throw new ArgumentException("Bug ref not set", "theEvent"); } } String bugId = null; if (m_Properties["CabAddedSetBugId"] == "True") { bugId = "TestCabAddedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } if ((m_Properties["ManualCabAddedSetBugId"] == "True") && (reportType != BugTrackerReportType.Automatic)) { if (m_CabsPerEvent.ContainsKey(theEvent.EventId)) { if (!theEvent.PlugInBugReference.StartsWith("ManualCabAddedSetBugId", StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException("Plug-in bug reference should be set already", "theEvent"); } m_CabsPerEvent[theEvent.EventId]++; } else { m_CabsPerEvent[theEvent.EventId] = 1; } bugId = "ManualCabAddedSetBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } m_CabAddedCount++; return(bugId); }
public string CabNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerNote note) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (cab == null) { throw new ArgumentNullException("cab"); } if (note == null) { throw new ArgumentNullException("note"); } if (cab.CabPathAndFileName == null) { throw new ArgumentException("Cab path is null", "cab"); } m_LastCabNote = note.Note; BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Cab Note Added: " + note.ToString()); // If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should // also contain the bug reference. if (m_Properties["SetBugId"] == "True") { if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture)) { throw new ArgumentException("Bug ref not set", "theEvent"); } } m_CabNoteAddedCount++; String bugId = null; if (m_Properties["CabNoteAddedBugId"] == "True") { bugId = "TestCabNoteAddedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } if ((m_Properties["ManualCabAddedSetBugId"] == "True") && (reportType != BugTrackerReportType.Automatic)) { bugId = "ManualCabAddedSetBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } return(bugId); }
/// <summary> /// Process a debug script change. /// </summary> private bool processDebugScriptUpdate(StackHashBugTrackerUpdate update) { // Get the associated product and file information. StackHashProduct product = m_Index.GetProduct((int)update.ProductId); StackHashFile file = m_Index.GetFile(product, (int)update.FileId); StackHashEvent theEvent = m_Index.GetEvent(product, file, new StackHashEvent((int)update.EventId, update.EventTypeName)); DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: getting cab data1"); StackHashCab cab = m_Index.GetCab(product, file, theEvent, (int)update.CabId); DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: getting cab data2"); StackHashNoteEntry note = m_Index.GetCabNote((int)update.ChangedObjectId); if ((product == null) || (file == null) || (theEvent == null) || (cab == null) || (note == null)) { if (product == null) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: Inconsistent Update Table Entry : product"); } if (file == null) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: Inconsistent Update Table Entry : file"); } if (theEvent == null) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: Inconsistent Update Table Entry : the Event"); } if (cab == null) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: Inconsistent Update Table Entry : cab: " + update.CabId.ToString(CultureInfo.InvariantCulture)); } if (note == null) { DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Debug Script: Inconsistent Update Table Entry : note"); } return(false); } BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id); BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id); NameValueCollection eventSignature = new NameValueCollection(); foreach (StackHashParameter param in theEvent.EventSignature.Parameters) { eventSignature.Add(param.Name, param.Value); } BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); NameValueCollection analysis = new NameValueCollection(); analysis.Add("DotNetVersion", cab.DumpAnalysis.DotNetVersion); analysis.Add("MachineArchitecture", cab.DumpAnalysis.MachineArchitecture); analysis.Add("OSVersion", cab.DumpAnalysis.OSVersion); analysis.Add("ProcessUpTime", cab.DumpAnalysis.ProcessUpTime); analysis.Add("SystemUpTime", cab.DumpAnalysis.SystemUpTime); String cabFileName = m_Index.GetCabFileName(product, file, theEvent, cab); BugTrackerCab btCab = new BugTrackerCab(cab.Id, cab.SizeInBytes, cab.CabDownloaded, cab.Purged, analysis, cabFileName); BugTrackerNote btCabNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note); // A note entry will be written when a script is run. Pick out the name of the script. // Format is "Script {0} executed". int startIndex = btCabNote.Note.IndexOf("Script ", StringComparison.OrdinalIgnoreCase) + "Script ".Length; int endIndex = btCabNote.Note.IndexOf("executed", StringComparison.OrdinalIgnoreCase) - 2; int length = endIndex - startIndex + 1; String scriptName = btCabNote.Note.Substring(startIndex, length); StackHashScriptResult stackHashScriptResult = m_TaskParameters.TheScriptResultsManager.GetResultFileData(product, file, theEvent, cab, scriptName); if (stackHashScriptResult == null) { return(false); } BugTrackerScriptResult btScriptResult = new BugTrackerScriptResult(stackHashScriptResult.Name, stackHashScriptResult.ScriptVersion, stackHashScriptResult.LastModifiedDate, stackHashScriptResult.RunDate, stackHashScriptResult.ToString()); String newBugId = null; if (update.TypeOfChange == StackHashChangeType.NewEntry) { newBugId = m_TaskParameters.PlugInContext.DebugScriptExecuted(null, BugTrackerReportType.Automatic, btProduct, btFile, btEvent, btCab, btScriptResult); } setPlugInBugReference(product, file, theEvent, newBugId); return(true); }
public string DebugScriptExecuted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerScriptResult scriptResult) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (cab == null) { throw new ArgumentNullException("cab"); } if (scriptResult == null) { throw new ArgumentNullException("scriptResult"); } BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Script Added: " + scriptResult.ToString()); // If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should // also contain the bug reference. if (m_Properties["SetBugId"] == "True") { if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture)) { throw new ArgumentException("Bug ref not set", "theEvent"); } } m_ScriptRunCount++; String bugId = null; if (m_Properties["DebugScriptExecutedBugId"] == "True") { bugId = "TestDebugScriptExecutedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture); } return(bugId); }
/// <summary> /// Processes a specific event. /// </summary> private void processEventPackage(StackHashBugReportData request, StackHashProduct product, StackHashFile file, StackHashEventPackage eventPackage) { if (this.CurrentTaskState.AbortRequested) { throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins"); } StackHashEvent theEvent = eventPackage.EventData; BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id); BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id); NameValueCollection eventSignature = new NameValueCollection(); foreach (StackHashParameter param in theEvent.EventSignature.Parameters) { eventSignature.Add(param.Name, param.Value); } BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); if (((request.Options & StackHashReportOptions.IncludeEvents) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { String newBugId = m_TaskParameters.PlugInContext.EventAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); } if (((request.Options & StackHashReportOptions.IncludeEventNotes) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { StackHashNotes notes = m_Index.GetEventNotes(product, file, theEvent); foreach (StackHashNoteEntry note in notes) { if (this.CurrentTaskState.AbortRequested) { throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins"); } BugTrackerNote btEventNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note); String newBugId = m_TaskParameters.PlugInContext.EventNoteAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent, btEventNote); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); } } if (request.Cab == null) { foreach (StackHashCabPackage cab in eventPackage.Cabs) { processCab(request, product, file, theEvent, cab.Cab, btProduct, btFile, btEvent); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); } } else { StackHashCab cab = m_Index.GetCab(product, file, theEvent, request.Cab.Id); if (cab != null) { theEvent = processCab(request, product, file, theEvent, cab, btProduct, btFile, btEvent); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); } } // Signal the completion of this event. if (((request.Options & StackHashReportOptions.IncludeEvents) != 0) || ((request.Options & StackHashReportOptions.IncludeAllObjects) != 0)) { String newBugId = m_TaskParameters.PlugInContext.EventManualUpdateCompleted(m_PlugIns, m_ReportType, btProduct, btFile, btEvent); checkPlugInStatus(m_PlugIns); theEvent = setPlugInBugReference(product, file, theEvent, newBugId); // Reset this in case it has changed. btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature); } m_CurrentEvent++; reportProgress(m_CurrentEvent, m_TotalEvents, eventPackage.EventData.Id); }
public void InvokeEachMethodSpecifyCorrectPlugIn() { StackHashBugTrackerPlugInSelectionCollection plugIns = new StackHashBugTrackerPlugInSelectionCollection(); plugIns.Add(new StackHashBugTrackerPlugInSelection("TestPlugIn")); String dllLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); String[] folders = { dllLocation }; BugTrackerManager manager = new BugTrackerManager(folders); StackHashBugTrackerPlugInSettings plugInSettings = new StackHashBugTrackerPlugInSettings(); plugInSettings.PlugInSettings = new StackHashBugTrackerPlugInCollection(); plugInSettings.PlugInSettings.Add(new StackHashBugTrackerPlugIn()); plugInSettings.PlugInSettings[0].Name = "TestPlugIn"; plugInSettings.PlugInSettings[0].Enabled = true; BugTrackerContext plugInContext = new BugTrackerContext(manager, plugInSettings); Assert.AreEqual(true, manager.NumberOfPlugIns >= 1); StackHashBugTrackerPlugInDiagnosticsCollection fullDiagnostics = plugInContext.GetContextDiagnostics("TestPlugIn"); Assert.AreEqual(1, fullDiagnostics.Count); NameValueCollection diagnostics = fullDiagnostics[0].Diagnostics.ToNameValueCollection(); Assert.AreEqual("0", diagnostics["ProductAddedCount"]); Assert.AreEqual("0", diagnostics["ProductUpdatedCount"]); Assert.AreEqual("0", diagnostics["FileAddedCount"]); Assert.AreEqual("0", diagnostics["FileUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventAddedCount"]); Assert.AreEqual("0", diagnostics["EventUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventNoteAddedCount"]); Assert.AreEqual("0", diagnostics["CabAddedCount"]); Assert.AreEqual("0", diagnostics["CabUpdatedCount"]); Assert.AreEqual("0", diagnostics["CabNoteAddedCount"]); BugTrackerProduct product = new BugTrackerProduct("Name", "Version", 1); BugTrackerFile file = new BugTrackerFile("FileName", "FileVersion", 2); BugTrackerEvent theEvent = new BugTrackerEvent("BugRef", "PlugInBugRef", 1, "EventTypeName", 1, new NameValueCollection()); BugTrackerCab cab = new BugTrackerCab(1, 100, false, false, new NameValueCollection(), "c:\\test.cab"); plugInContext.ProductAdded(plugIns, BugTrackerReportType.Automatic, product); plugInContext.ProductUpdated(plugIns, BugTrackerReportType.Automatic, product); plugInContext.FileAdded(plugIns, BugTrackerReportType.Automatic, product, file); plugInContext.FileUpdated(plugIns, BugTrackerReportType.Automatic, product, file); plugInContext.EventAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventUpdated(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventManualUpdateCompleted(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventNoteAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, new BugTrackerNote()); plugInContext.CabAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab); plugInContext.CabUpdated(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab); plugInContext.CabNoteAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab, new BugTrackerNote()); fullDiagnostics = plugInContext.GetContextDiagnostics("TestPlugIn"); Assert.AreEqual(1, fullDiagnostics.Count); diagnostics = fullDiagnostics[0].Diagnostics.ToNameValueCollection(); Assert.AreEqual("1", diagnostics["ProductAddedCount"]); Assert.AreEqual("1", diagnostics["ProductUpdatedCount"]); Assert.AreEqual("1", diagnostics["FileAddedCount"]); Assert.AreEqual("1", diagnostics["FileUpdatedCount"]); Assert.AreEqual("1", diagnostics["EventAddedCount"]); Assert.AreEqual("1", diagnostics["EventCompleteCount"]); Assert.AreEqual("1", diagnostics["EventUpdatedCount"]); Assert.AreEqual("1", diagnostics["EventNoteAddedCount"]); Assert.AreEqual("1", diagnostics["CabAddedCount"]); Assert.AreEqual("1", diagnostics["CabUpdatedCount"]); Assert.AreEqual("1", diagnostics["CabNoteAddedCount"]); }
/// <summary> /// This method is called when the processing of an Event has completed. Events have associated Cabs, Scripts and notes which /// may all be reported during a MANUAL Bug Report. This call effectively delimits the reporting of all /// information associated with an event so, if desired, the plug-in can gather all of the information together in one /// go for sending to the fault database. This may improve performance for events with large amounts of stored data. /// /// The plug-in may thus see... /// EventAdded /// EventNoteAdded, EventNoteAdded,... /// CabAdded, CabAdded,... /// CabNoteAdded, CabNoteAdded,... /// ScriptResultAdded, ScriptResultAdded,... /// EventManualUpdateCompleted. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event whose details have now been reported.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } // Don't change the bug reference. Setting this to any other value will update the bug reference in the // StackHash database. String plugInBugId = null; // Note that all of the interface objects have a built in ToString() which formats the fields suitably. BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Event Completed: " + theEvent.ToString()); return(plugInBugId); }
public void LogInCallback() { // Empty so shouldn't report anything. StackHashBugTrackerPlugInSelectionCollection plugIns = new StackHashBugTrackerPlugInSelectionCollection(); String dllLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); String[] folders = { dllLocation }; BugTrackerTrace.LogMessageHook += new EventHandler <BugTrackerTraceEventArgs>(LogPlugInEvent); try { BugTrackerManager manager = new BugTrackerManager(folders); StackHashBugTrackerPlugInSettings plugInSettings = new StackHashBugTrackerPlugInSettings(); plugInSettings.PlugInSettings = new StackHashBugTrackerPlugInCollection(); plugInSettings.PlugInSettings.Add(new StackHashBugTrackerPlugIn()); plugInSettings.PlugInSettings[0].Name = "TestPlugIn"; plugInSettings.PlugInSettings[0].Enabled = true; BugTrackerContext plugInContext = new BugTrackerContext(manager, plugInSettings); Assert.AreEqual(true, manager.NumberOfPlugIns >= 1); Assert.AreEqual(true, m_CallBackCount > 0); StackHashBugTrackerPlugInDiagnosticsCollection fullDiagnostics = plugInContext.GetContextDiagnostics("TestPlugIn"); Assert.AreEqual(1, fullDiagnostics.Count); NameValueCollection diagnostics = fullDiagnostics[0].Diagnostics.ToNameValueCollection(); Assert.AreEqual("0", diagnostics["ProductAddedCount"]); Assert.AreEqual("0", diagnostics["ProductUpdatedCount"]); Assert.AreEqual("0", diagnostics["FileAddedCount"]); Assert.AreEqual("0", diagnostics["FileUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventAddedCount"]); Assert.AreEqual("0", diagnostics["EventUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventNoteAddedCount"]); Assert.AreEqual("0", diagnostics["CabAddedCount"]); Assert.AreEqual("0", diagnostics["CabUpdatedCount"]); Assert.AreEqual("0", diagnostics["CabNoteAddedCount"]); BugTrackerProduct product = new BugTrackerProduct("Name", "Version", 1); BugTrackerFile file = new BugTrackerFile("FileName", "FileVersion", 2); BugTrackerEvent theEvent = new BugTrackerEvent("BugRef", "PlugInBugRef", 1, "EventTypeName", 1, new NameValueCollection()); BugTrackerCab cab = new BugTrackerCab(1, 100, false, false, new NameValueCollection(), "c:\\test.cab"); plugInContext.ProductAdded(plugIns, BugTrackerReportType.Automatic, product); plugInContext.ProductUpdated(plugIns, BugTrackerReportType.Automatic, product); plugInContext.FileAdded(plugIns, BugTrackerReportType.Automatic, product, file); plugInContext.FileUpdated(plugIns, BugTrackerReportType.Automatic, product, file); plugInContext.EventAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventUpdated(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventManualUpdateCompleted(plugIns, BugTrackerReportType.Automatic, product, file, theEvent); plugInContext.EventNoteAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, new BugTrackerNote()); plugInContext.CabAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab); plugInContext.CabUpdated(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab); plugInContext.CabNoteAdded(plugIns, BugTrackerReportType.Automatic, product, file, theEvent, cab, new BugTrackerNote()); fullDiagnostics = plugInContext.GetContextDiagnostics("TestPlugIn"); Assert.AreEqual(1, fullDiagnostics.Count); diagnostics = fullDiagnostics[0].Diagnostics.ToNameValueCollection(); Assert.AreEqual("0", diagnostics["ProductAddedCount"]); Assert.AreEqual("0", diagnostics["ProductUpdatedCount"]); Assert.AreEqual("0", diagnostics["FileAddedCount"]); Assert.AreEqual("0", diagnostics["FileUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventAddedCount"]); Assert.AreEqual("0", diagnostics["EventCompleteCount"]); Assert.AreEqual("0", diagnostics["EventUpdatedCount"]); Assert.AreEqual("0", diagnostics["EventNoteAddedCount"]); Assert.AreEqual("0", diagnostics["CabAddedCount"]); Assert.AreEqual("0", diagnostics["CabUpdatedCount"]); Assert.AreEqual("0", diagnostics["CabNoteAddedCount"]); } finally { BugTrackerTrace.LogMessageHook -= new EventHandler <BugTrackerTraceEventArgs>(LogPlugInEvent); } }
/// <summary> /// If the report type is automatic then this call indicates that a Debug Script Result has been added to the /// StackHash database by way the Cab Analysis task running or the StackHash client manually running a script /// on a cab. /// /// If the report type is manual then this call indicates that an Debug Script Result already exists in the /// StackHash database. This is the result of a BugReport task being run. /// /// scriptResult.ToString() can be used to format the string for addition to a Fault Database system. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event to which the cab belongs.</param> /// <param name="cab">The cab to which the debug script result belongs.</param> /// <param name="scriptResult">The result of running a debug script on the cab dump file.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string DebugScriptExecuted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerScriptResult scriptResult) { if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } if (cab == null) { throw new ArgumentNullException("cab"); } if (scriptResult == null) { throw new ArgumentNullException("scriptResult"); } // Note that all of the interface objects have a built in ToString() which formats the fields suitably. BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Debug Script Added: " + scriptResult.ToString()); // Don't change the plugin bug reference. return(null); }
/// <summary> /// If the report type is automatic then this call indicates that an Event has been added to the /// StackHash database by way of a Synchronize with the WinQual web site. /// /// If the report type is manual then this call indicates that an Event already exists in the /// StackHash database. This is the result of a BugReport task being run. /// /// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed /// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired /// bug reference from this call. /// Return null if you do NOT want to change the bug reference stored in the StackHash database. /// Return any other string (including an empty string) and this value will be used to overwrite the /// plugin bug reference in the StackHash database. /// Note that there are 2 bug references: /// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin. /// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin. /// /// Files are mapped to products on the WinQual site. Note that the same file may be mapped to one /// or more products and therefore the same event (associated with a file) may "belong" refer to more /// than one product. /// /// Note that it is therefore possible that the event existence has already been reported, so the /// code here should check, if necessary, that this is not a duplicate before creating new items in /// the destination bug tracking system. /// /// Important Note: AN EVENT IS IDENTIFIED BY ITS ID AND EVENTTYPENAME TOGETHER. Therefore it is possible to /// have events with the same ID but different EventTypeName. /// /// Note also that event IDs can be negative. This is a consequence of the WinQual site storing event numbers as /// 32 bit signed quantities. When the event ID range was exhausted the WinQual events went negative. The StackHash /// database stores event IDs as 64 bit signed quantities to future proof against any future changes in the /// WinQual values. /// /// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync /// is happening at the same time as a manual report is requested. /// </summary> /// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param> /// <param name="product">The product to which the file belongs.</param> /// <param name="file">The file to which the event belongs.</param> /// <param name="theEvent">The event being added.</param> /// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns> public string EventAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent) { if (m_disposed) { throw new ObjectDisposedException("EmailPluginContext"); } if (product == null) { throw new ArgumentNullException("product"); } if (file == null) { throw new ArgumentNullException("file"); } if (theEvent == null) { throw new ArgumentNullException("theEvent"); } // do nothing on an automatic report if we're in manaual mode if ((reportType == BugTrackerReportType.Automatic) && (m_Settings.IsManualOnly)) { return(null); } string subjectTemplate = null; string messageTemplate = null; if (reportType == BugTrackerReportType.Automatic) { subjectTemplate = StackHash.EmailPlugin.Properties.Resources.EventAdded_SubjectTemplate; messageTemplate = StackHash.EmailPlugin.Properties.Resources.EventAdded_MessageTemplate; } else { subjectTemplate = StackHash.EmailPlugin.Properties.Resources.EventManualReport_SubjectTemplate; messageTemplate = StackHash.EmailPlugin.Properties.Resources.EventManaulReport_MessageTemplate; } // build a string containing all event signature parameters StringBuilder eventSignatureBuilder = new StringBuilder(); foreach (string key in theEvent.Signature.Keys) { eventSignatureBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0} = {1}", key, theEvent.Signature[key]); eventSignatureBuilder.AppendLine(); eventSignatureBuilder.AppendLine(); } try { string subject = string.Format(CultureInfo.CurrentCulture, subjectTemplate, product.ProductName, product.ProductVersion, theEvent.EventId); string message = string.Format(CultureInfo.CurrentCulture, messageTemplate, product.ProductName, product.ProductVersion, theEvent.EventId, theEvent.EventTypeName, theEvent.TotalHits, eventSignatureBuilder); m_Settings.SendEmail(subject, message); m_EmailsSent++; } catch (Exception ex) { BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.ComponentFatal, m_Control.PlugInName, string.Format(CultureInfo.InvariantCulture, "Failed to send event email: {0}", ex)); m_LastException = ex; m_FailedEmails++; throw; } // Don't change the plugin bug reference. Setting this to any other value will update the plugin bug reference in the // StackHash database. string pluginBugReference = null; return(pluginBugReference); }