Debugging and Logging Capabilities in SharePoint 2010

Page 1 of 16

Debugging and Logging Capabilities in SharePoint 2010

SharePoint 2010 Published: December 2010 Summary: Learn about the new logging and debugging capabilities in SharePoint Foundation 2010 that enable developers to build more reliable and testable solutions. Applies to: Microsoft SharePoint Foundation 2010 | Microsoft SharePoint Server 2010 | Microsoft Visual Studio 2010 Provided by: Andrew Connell (SharePoint MVP), Critical Path Training, LLC Contents Introduction to Debugging and Logging in SharePoint 2010 Logging in SharePoint 2010 Error Reporting in SharePoint 2010 Custom SharePoint Application Pages SharePoint 2010 Developer Dashboard Conclusion Additional Resources
1

Download code

Introduction to Debugging and Logging in SharePoint 2010

Microsoft SharePoint 2010 is a very extensible product that developers can customize to suit various business needs. Because SharePoint is based on Microsoft ASP.NET, it provides developers with the same debugging and logging options that are available to traditional ASP.NET websites. In addition to what ASP.NET provides, SharePoint 2010 introduces additional options to assist developers in monitoring and troubleshooting applications in the areas of debugging and logging. This article touches on various debugging and logging points and techniques that developers can use in their custom SharePoint 2010 applications. What's New in SharePoint 2010 for Logging and Debugging The best applications contain a good measure of logging to assist developers in tracking down errors when things do not go as they were designed or when unexpected things occur. Microsoft Office SharePoint Server 2007 offered developers all the tools that were available in ASP.NET, such as the debug and trace log. Developers could also write to the SharePoint log, known as the Unified Logging Service (ULS), but it required some extra work to write directly to the log files.

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 2 of 16

Microsoft added more logging and debugging capabilities to SharePoint 2010 to help developers include additional monitoring and troubleshooting to their custom applications. This article addresses the following new areas in SharePoint 2010: Correlation tokens Logging database Custom error pages Developer Dashboard

Logging in SharePoint 2010

Every server running Windows SharePoint Services 3.0 and Office SharePoint Server 2007 wrote logging information to the ULS log files and server event log. The ULS log files, found in the {SharePoint Root}\LOGS folder on each server running SharePoint in the farm, could contain quite a bit of information, depending on how the diagnostic log throttling was configured. Although more logging detail is usually favored over less detail, it can be challenging to find a specific entry in the log files. SharePoint 2010 improves on this task of finding specific log entries by assigning some uniqueness to each log entry. This uniqueness, known as a correlation token, is a GUID that is presented to the user when an error occurs. An administrator or developer can then take this GUID string in the error and use it in searching for a specific entry in the log file. This speeds the process of finding entries in the log files for tracking down specific incidents. The ULS can also be configured to determine how much detail is included in the log files and event log, based on specific criteria. The article Configure diagnostic logging (SharePoint Foundation 2010)3 (Microsoft TechNet) demonstrates how to configure the diagnostic logging in SharePoint 2010. SharePoint Logging Database Another change Microsoft introduced is a new database that contains all logging information for all servers in the farm. This is done through the use of a few new timer jobs. After these jobs are enabled (they are all disabled by default), SharePoint inserts diagnostic logging data into a new Microsoft SQL Server database. The following are the new timer jobs: Diagnostic Data Provider: Event Log Diagnostic Data Provider: Performance Counters - Database Servers Diagnostic Data Provider: Performance Counters - Web Front Ends Diagnostic Data Provider: SQL Blocking Queries Diagnostic Data Provider: SQL DMV Diagnostic Data Provider: SQL Memory DMV Diagnostic Data Provider: Trace Log Details for each of these timer jobs are documented in Timer Job Reference (SharePoint Server 4 2010) . One of the biggest advantages to enabling these jobs is that all the various logs are aggregated into a single location that can be queried from various sources. The contents of this

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 3 of 16

logging database could even be exposed by using Microsoft Business Connectivity Services (BCS) external content types and lists. Reading the SharePoint ULS Logs In addition to the new logging database in SharePoint 2010, developers can also analyze the raw SharePoint log files that are created in the {SharePoint Root}\LOGS folder on each server. When developing solutions, developers typically work in an isolated environment where everything is installed on a single server instead of on a farm consisting of various servers. The log files are simply large fixed-width delimited text files that can be read and searched by using any text editor. In addition to searching raw text files, quite a few developers have published various utilities that 5 assist in reading the SharePoint log files. A quick search for SharePoint ULS viewer yields numerous resources. Some of these utilities include notifications and ways to make searching and filtering for specific criteria much easier than by using a standard text editor. Writing to the SharePoint ULS Logs Reading from the SharePoint ULS logs is helpful when troubleshooting SharePoint generated messages. But one thing developers really need is the ability to write their own messages to the log files. Microsoft made it much easier to write to the log files in SharePoint 2010 by using the SPDiagnosticsService class, as shown in the following example.

C#
try{ ... }catch(Exceptionex){ SPDiagnosticsService.Local.WriteTrace(0,newSPDiagnosticsCategory("MSDN",TraceSe verity.Unexpected,EventSeverity.Error),TraceSeverity.Unexpected,ex.Message,ex.St ackTrace); } The previous code snippet will write the exception details to the SharePoint ULS log. Upon inspecting the entry that is added, developers will notice that the entry for the Product column is Unknown. This is the default behavior of the SPDiagnosticsService class. To add custom product names, developers can implement their own diagnostics service by using the SPDiagnosticsServiceBase class. Unfortunately, interacting with a custom SPDiagnosticsService is available only in fully trusted farm solutions and not within sandboxed solutions. To write to the ULS logs by using the SPDiagnosticsService class from the sandbox, developers can create a full trust proxy that the sandboxed solutions can call into. The next two sections describe how to write to the SharePoint ULS logs. In addition to writing a custom SPDiagnosticsService class, the Microsoft patterns & practices group has released the Developing Applications for SharePoint 20106 guidance package, which includes a SharePoint logger. Developers should consider all these approaches when building custom applications. Creating a Custom Logging Service Creating a custom logging service in a custom application involves creating a new implementation of the SPDiagnosticsServiceBase class, overwriting a single method, and providing a few ways to write to the log files.

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 4 of 16

The following example shows how to add a new class to a non-sandboxed solution and have the class inherit from the SPDiagnosticsServiceBase class.

C#
usingSystem; usingSystem.Collections.Generic; usingSystem.Linq; usingSystem.Text; usingMicrosoft.SharePoint.Administration; namespaceMSDN.SharePoint.Samples.WriteToUls{ publicclassLoggingService:SPDiagnosticsServiceBase{ privateLoggingService(): base("MSDNLoggingService",SPFarm.Local){} } } Next, implement the ProvideAreas method that will register the product name and logging categories available, as shown in the following example.

C#
publicconststringMSDN_INFO="MSDNInfo"; publicconststringMSDN_ERROR="MSDNError"; privatestaticstringPRODUCT_DIAGNOSTIC_NAME="MSDNSample"; protectedoverrideIEnumerable<SPDiagnosticsArea>ProvideAreas(){ List<SPDiagnosticsArea>areas=newList<SPDiagnosticsArea>{ newSPDiagnosticsArea(PRODUCT_DIAGNOSTIC_NAME,newList<SPDiagnosticsCategory>{ newSPDiagnosticsCategory(MSDN_INFO,TraceSeverity.Verbose,EventSeverity.Info rmation), newSPDiagnosticsCategory(MSDN_ERROR,TraceSeverity.Unexpected,EventSeverity. Warning), }) }; returnareas; } The following example shows the last step, which is to make the custom logging service easy to use by adding a few static methods that can be called from custom components, such as Web Parts.

C#
privatestaticLoggingService_current; publicstaticLoggingServiceCurrent{ get{ if(_current==null) _current=newLoggingService(); return_current; } } publicstaticvoidLogMessage(stringcategoryName,stringmessage){

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 5 of 16

SPDiagnosticsCategorycategory= LoggingService.Current.Areas[PRODUCT_DIAGNOSTIC_NAME].Categories[categoryName]; LoggingService.Current.WriteTrace(0,category,TraceSeverity.Verbose,message); } publicstaticvoidLogError(stringcategoryName,stringmessage){ SPDiagnosticsCategorycategory= LoggingService.Current.Areas[PRODUCT_DIAGNOSTIC_NAME].Categories[categoryName]; LoggingService.Current.WriteTrace(0,category,TraceSeverity.Unexpected,message); } Test the logger by adding a custom component to the project, such as a Web Part, and call the logging service, as shown in the following example.

C#
publicclassWriteToUlsFarmSolutionWebPart:WebPart{ protectedoverridevoidCreateChildControls(){ ButtonlogInfoButton=newButton{Text="loginfoentry"}; logInfoButton.Click+=(sender,e)=> LoggingService.LogMessage(LoggingService.MSDN_INFO,"Sampleinfomessage."); this.Controls.Add(logInfoButton); ButtonlogErrorButton=newButton{Text="logerrorentry"}; logErrorButton.Click+=(sender,e)=> LoggingService.LogMessage(LoggingService.MSDN_ERROR,"Sampleerrormessage."); this.Controls.Add(logErrorButton); } } When the previous code is run by clicking one of the buttons in the Web Part, a new entry is added to the SharePoint log file by using the product name MSDN Sample and one of the new categories. Writing to the ULS Logs from Sandboxed Solutions Unfortunately, writing to the ULS logs directly is not possible from within a sandboxed solution. This is because the sandboxed solution does not have access to the logging service from the isolated user code service. However, developers can create a full trust proxy that is deployed as a farm solution, and then any sandboxed solution could take advantage of this full trust proxy. For a detailed walkthrough about creating a full trust proxy, see How To: Create and Register a Sandbox Proxy7. Create a farm solution by using the SharePoint development tools in Microsoft Visual Studio 2010, and create the same SPDiagnosticsServiceBase logging class that was created previously. The next step is to create the proxy that will call the logging service. Add another class to the project that will take the proxy operation arguments, as shown in the following example.

C#
usingSystem; usingSystem.Collections.Generic; usingSystem.Linq;

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 6 of 16

usingSystem.Text; usingMicrosoft.SharePoint.UserCode; namespaceMSDN.SharePoint.Samples.WriteToUls{ [Serializable] publicclassLoggingMessageProxyArguments:SPProxyOperationArgs{ publicstringMessageCategoryName{get;set;} publicstringMessageContents{get;set;} publicstaticstringLoggingProxyOperationTypeName{ get{ return"LoggingProxy.LoggingMessageProxyOperation"; } } publicstaticstringLoggingProxyAssemblyName{ get{ return"MSDN.SharePoint.Samples.WriteToUlsSandboxSolution.Proxy,Version=1.0. 0.0,Culture=neutral,PublicKeyToken=[INSERTPROJECT'SPUBLICKEYTOKENHERE]"; } } } } Next, add another class to the project that performs the fully trusted operation, as shown in the following example.

C#
usingSystem; usingSystem.Collections.Generic; usingSystem.Linq; usingSystem.Text; usingMicrosoft.SharePoint.UserCode; namespaceMSDN.SharePoint.Samples.WriteToUls{ publicclassLoggingMessageProxyOperation:SPProxyOperation{ publicoverrideobjectExecute(SPProxyOperationArgsargs){ LoggingMessageProxyArgumentsproxyArguments=argsasLoggingMessageProxyArgum ents; stringloggingCategory; switch(proxyArguments.MessageCategoryName.ToLower()){ caseLoggingService.MSDN_ERROR: loggingCategory=LoggingService.MSDN_ERROR; break; default: loggingCategory=LoggingService.MSDN_INFO; break; } //Dofulltrustaction. LoggingService.LogMessage(loggingCategory,proxyArguments.MessageContents); } }

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 7 of 16

} With the proxy's arguments and operation created, the last step is to register it with the user code service in the farm. This can be done by using the activated event in a farm-scoped Feature, as shown in the following example.

C#
publicclassLoggingMessageProxyInstallerEventReceiver:SPFeatureReceiver{ publicoverridevoidFeatureActivated(SPFeatureReceiverPropertiesproperties){ //Getproxyoperation. LoggingMessageProxyOperationproxyOperation=newSPProxyOperationType( LoggingMessageProxyArguments.LoggingProxyAssemblyNam e, LoggingMessageProxyArguments.LoggingProxyOperationTy peName); SPUserCodeServiceucService=SPUserCodeService.Local; ucService.ProxyOperationTypes.Add(proxyOperation); ucService.Update(); } publicoverridevoidFeatureDeactivating(SPFeatureReceiverPropertiesproperties){ //Getproxyoperation. LoggingMessageProxyOperationproxyOperation=newSPProxyOperationType( LoggingMessageProxyArguments.LoggingProxyAssemblyNam e, LoggingMessageProxyArguments.LoggingProxyOperationTy peName); //Addproxytousercodeservice. SPUserCodeServiceucService=SPUserCodeService.Local; ucService.ProxyOperationTypes.Remove(proxyOperation); ucService.Update(); } } After this project is deployed and the included farm-scoped Feature is activated, the proxy can be called from within a sandboxed solution. The following code shows how a Web Part that is deployed in a sandboxed solution can use the full trust proxy and write to the SharePoint 2010 ULS logs.

C#
publicclassWriteToUlsSandboxSolutionWebPart:WebPart{ protectedoverridevoidCreateChildControls(){ LoggingMessageProxyArgumentsloggingProxyArgs=newLoggingMessageProxyArguments (); ButtonlogInfoButton=newButton{Text="loginfoentry"}; logInfoButton.Click+=(sender,e)=>{ loggingProxyArgs.MessageCategoryName=LoggingService.MSDN_INFO; loggingProxyArgs.MessageContents="Sampleinfomessage"; varresult1=SPUtility.ExecuteRegisteredProxyOperation(

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 8 of 16

LoggingMessageProxyArguments.LoggingProxyAssemblyName, LoggingMessageProxyArguments.LoggingProxyOperationTypeName, loggingProxyArgs); }; this.Controls.Add(logInfoButton); ButtonlogErrorButton=newButton{Text="logerrorentry"}; logInfoButton.Click+=(sender,e)=>{ loggingProxyArgs.MessageCategoryName=LoggingService.MSDN_ERROR; loggingProxyArgs.MessageContents="Sampleinfomessage"; varresult2=SPUtility.ExecuteRegisteredProxyOperation( LoggingMessageProxyArguments.LoggingProxyAssemblyName, LoggingMessageProxyArguments.LoggingProxyOperationTypeName, loggingProxyArgs); }; this.Controls.Add(logErrorButton); } } For guidelines about writing the logging event and trace events to the ULS logs, see Trace and 8 Event Log Severity Levels in the SharePoint 2010 SDK

Error Reporting in SharePoint 2010

Adding copious amounts of logging to custom projects is a good idea for developers because it helps track down problems when they occur. However, there will always be times when errors still occur that developers will have to track down. In addition, developers may want to change some of the default system pages that SharePoint 2010 uses. The following sections describe these two scenarios. Using the Web Application web.config File When errors occur in an ASP.NET application, they are shown either in their raw state (when the web.config file contains the element <customErrors mode="Off" />), or by using a custom error page to hide the details of the error and display a custom message (when the web.config file contains the element <customErrors mode="On" />). The default configuration in SharePoint 2010 is to turn custom errors on and not show the details of the error. One reason for this is so users do not see unfriendly errors, and instead are presented with a more graceful error page. Another reason for not including the full details is because providing complete details of an error could be considered a security flaw as it may expose more information that should be exposed to users. Unfortunately, the custom error messages delivered by SharePoint are sometimes not detailed enough for developers to troubleshoot the problem. When building custom solutions, it is helpful to see the full error including the specific exception, the exception message, and the complete call stack. This can be achieved easily by modifying the web application's web.config file and changing the mode in the <customErrors /> element to Off. This will display the raw ASP.NET error page for the entire web application. This process can also be automated by using a web application scoped Feature, by implementing the Feature's activated and deactivated events to make this change, as shown in the following example.

C#

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 9 of 16

publicoverridevoidFeatureActivated(SPFeatureReceiverPropertiesproperties){ SPWebApplicationWebApp=(SPWebApplication)properties.Feature.Parent; foreach(ModificationEntrymodEntryinEntries){ WebApp.WebConfigModifications.Add( CreateModification(modEntry) ); } WebApp.WebService.ApplyWebConfigModifications(); } publicoverridevoidFeatureDeactivating(SPFeatureReceiverPropertiesproperties){ SPWebApplicationWebApp=(SPWebApplication)properties.Feature.Parent; foreach(ModificationEntrymodEntryinEntries){ WebApp.WebConfigModifications.Remove( CreateModification(modEntry) ); } WebApp.WebService.ApplyWebConfigModifications(); } privatestructModificationEntry{ publicstringName; publicstringXPath; publicstringValue; publicSPWebConfigModification.SPWebConfigModificationTypeModType; //Parameterizedcontructor.publicModificationEntry( stringName,stringXPath,stringValue, SPWebConfigModification.SPWebConfigModificationTypeModType){ //Intializestructureinstances.this.Name=Name; this.XPath=XPath; this.Value=Value; this.ModType=ModType; } } privateModificationEntry[]Entries={ newModificationEntry( "mode","configuration/system.web/customErrors","Off", SPWebConfigModification.SPWebConfigModificationType.EnsureAttribute) }; privateSPWebConfigModificationCreateModification(ModificationEntrymodEntry){ //CreateandreturnSPWebConfigModificationobject. SPWebConfigModificationmodification; modification=newSPWebConfigModification(modEntry.Name,modEntry.XPath); modification.Owner="MSDN.SharePointDebugger"; modification.Sequence=0; modification.Type=modEntry.ModType; modification.Value=modEntry.Value; returnmodification; }

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 10 of 16

Using the Layouts web.config File You should keep in mind that folders in a web application inherit the web.config file settings from their parent folders, unless they are overwritten by a local web.config file. Specific to SharePoint 2010, the http://.../_layouts folder contains its own web.config file that has the custom errors turned on. Therefore, when creating custom application pages or troubleshooting the SharePoint 2010 application pages, developers may want to either modify the web.config located in the {SharePoint Root}\TEMPLATE\LAYOUTS folder, or add a custom web.config that turns off custom errors in the folder containing the custom application pages.

Custom SharePoint Application Pages

SharePoint 2010 includes numerous system application pages for things such as reporting errors, access-denied notifications, and logon and logoff pages. In earlier versions of SharePoint, these files were hard-coded. Although some were easy to change, such as the logon page that can be changed in the web.config file, others could not be changed without some very creative code. Microsoft improved this in SharePoint 2010 by giving developers a way to retrieve the URL of a custom page, and enabling developers to create their own system application pages. This enables developers to create custom system application pages that include custom business logic or that can be branded to match the rest of the site's branding. These changes can be applied to a web application using two methods: GetMappedPage and UpdateMappedPage. A list of the available system application pages that can be changed is found in the SPCustomPage9 enumeration. Changing a system master page is best implemented in the activated and deactivated events of a web applicationscoped Feature. First ,create a new application page that will serve the purpose of the custom system application page. Next, create a web applicationscoped Feature and implement the activated and deactivated events, as shown in the following example.

C#
publicclassCustomErrorPagesEventReceiver:SPFeatureReceiver{ publicoverridevoidFeatureActivated(SPFeatureReceiverPropertiesproperties) { SPWebApplicationwebApp=properties.Feature.ParentasSPWebApplication; if(webApp!=null){ //SetAccessDenied.if(!webApp.UpdateMappedPage(SPWebApplication.SPCustomPag e.AccessDenied, "/_layouts/CustomErrorPages/AccessDenied.aspx")){ thrownewApplicationException("Failedsettingnewaccessdeniedpagemapping ."); } //SetSignout.if(!webApp.UpdateMappedPage(SPWebApplication.SPCustomPage.Sign out, "/_layouts/CustomErrorPages/Signout.aspx")){ thrownewApplicationException("Failedsettingnewsignoutpagemapping."); } //SetFileNotFound. webApp.FileNotFoundPage="/_layouts/1033/FileNotFound.htm"; webApp.Update(true); } }

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 11 of 16

publicoverridevoid FeatureDeactivating(SPFeatureReceiverPropertiesproperties) { SPWebApplicationwebApp=properties.Feature.ParentasSPWebApplication; if(webApp!=null){ webApp.UpdateMappedPage(SPWebApplication.SPCustomPage.AccessDenied,null); webApp.UpdateMappedPage(SPWebApplication.SPCustomPage.Signout,null); webApp.FileNotFoundPage=null; } } }

SharePoint 2010 Developer Dashboard

The Developer Dashboard is another new addition to SharePoint 2010 to help developers with logging and debugging custom components that are added to SharePoint pages. The Developer Dashboard can be turned on for an entire farm to get a snapshot of the activity and performance of a specific page request.

Figure 1. Developer Dashboard

The Developer Dashboard can be very helpful in troubleshooting problematic components on a page, because a single SharePoint page can contain multiple custom components. When a page contains multiple custom components and the performance of a page is slower than desired, it can be hard to isolate which component is the root cause for the slow performance, other than by using

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 12 of 16

a simple process of elimination. This is exactly the scenario the Developer Dashboard is designed to assist with. The Developer Dashboard includes a few different categories of information. It provides details on how long it took treads to process, details on the quantity and execution duration of SQL Server database calls and Windows Communication Foundation (WCF) service calls, details on the URL, and the current user, and more. Configuring the Developer Dashboard By default, the Developer Dashboard is not turned on. Enabling the Developer Dashboard can be done either through the API or by using a custom Windows PowerShell script, as shown in the following example.

Windows PowerShell
$contentService=[Microsoft.SharePoint.Administration.SPWebService]::ContentService $dashboardSetting=$contentService.DeveloperDashboardSettings $dashboardSetting.DisplayLevel=[Microsoft.SharePoint.Administration.SPDeveloperDas hboardLevel]::On $dashboardSetting.Update() There are two different display levels available on the Developer Dashboard. The SPDeveloperDashboardLevel.On enumeration option enables the dashboard on all pages in a farm. Setting it to SPDeveloperDashboardLevel.OnDemand leaves it disabled, but adds a performance counter-like image to the top-right corner of the page. When this image is clicked, a postback is triggered that adds the Developer Dashboard to the page. For information about the Developer Dashboard, see Using the Developer Dashboard SharePoint 2010 SDK.
10

in the

Although the Developer Dashboard includes a considerable amount of information for SharePoint processes, developers can also add their own logging in custom components that appear in the dashboard. Writing to the Developer Dashboard Writing to the Developer Dashboard can be done only directly from farm solutions; sandboxed solutions cannot write to the Developer Dashboard because they are isolated in the user code process. To write to the Developer Dashboard, a custom component should be wrapped in a SPMonitoredScope object. The following code shows how to write to the Developer Dashboard and how to create nested scopes.

C#
publicclassMonitoredWebPart:WebPart{ protectedoverridevoidCreateChildControls(){ using(SPMonitoredScopescope=newSPMonitoredScope("MonitoredWebPart.CreateChi ldControls")){ this.Controls.Add( newLiteralControl("Turnonthedeveloperdashboardtoseeentriesloggedby thisWebPart.");

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 13 of 16

//TriggeraSPRequest&DBroundtrip. TriggerSpDatabaseRequest(); TriggerSPRequestObject(); //Simulateadelay. TriggerSimulatedDelay(); ); } } privatevoidTriggerSpDatabaseRequest(){ using(SPMonitoredScopescope=newSPMonitoredScope("MonitoredWebPart.TriggerSp DatabaseRequest")){ SPListsomeList=SPContext.Current.Web.Lists[0]; intitemsinList=someList.Items.Count(); } } privatevoidTriggerSPRequestObject(){ using(SPMonitoredScopescope=newSPMonitoredScope("MonitoredWebPart.TriggerSP RequestObject")){ using(SPSitesiteCollection=newSPSite(SPContext.Current.Site.Id)){ stringsiteCollectionUrl=siteCollection.RootWeb.Url; } } } privatevoidTriggerSimulatedDelay(){ using(SPMonitoredScopescope=newSPMonitoredScope("MonitoredWebPart.TriggerSi mulatedDelay")){ System.Threading.Thread.Sleep(2000); } } } Figure 2 shows the results of adding the Web Part shown in the previous code example to the page.

Figure 2. Writing to the Developer Dashboard

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 14 of 16

Adding the Developer Dashboard to Custom Master Pages The Developer Dashboard is included in all SharePoint sites that use one of the master pages included in SharePoint 2010. When creating custom master pages, developers can add the Developer Dashboard by simply adding the following server control, ideally to the bottom of the page: <SharePoint:DeveloperDashboard runat="server" /> When the Developer Dashboard is set to SPDeveloperDashboardLevel.OnDemand, it uses the dashboard launcher to display the icon and render the dashboard. Developers will also want to add the following control to custom master pages also: <SharePoint:DeveloperDashboardLauncher runat="server" /> This control contains a few public properties to change the placement, text, and image used to 11 render the control. These can be found in the DeveloperDashboardLauncher class in the SharePoint 2010 SDK.

Conclusion
Microsoft put a significant focus on the developer story in the latest release of SharePoint, Microsoft SharePoint 2010. In addition to the first-class developer tools included in Visual Studio 2010, Microsoft added considerable flexibility and capabilities for developers to add logging and debugging techniques to custom solutions built for SharePoint 2010. This article walks through some common logging and debugging techniques that are now available to developers when building SharePoint 2010 solutions.

Additional Resources
For more information, see the following resources: Logging For SharePoint Developers12
3 Configure Diagnostic Logging (SharePoint Foundation 2010) (TechNet)

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 15 of 16

Timer Job References (SharePoint Server 2010)4 (TechNet) Database Types and Descriptions (SharePoint Server 2010)
13

(TechNet)
14

Using Business Connectivity Services to Display SharePoint 2010 ULS Logs SharePoint ULS Log Viewer SharePoint Guidance
16 15

Using the Developer Dashboard10 SharePoint Development Center17

Change History

Date Description Reason

December 2010 Initial publication

Links Table
1 2 3 4 5 6 7 8 9

http://www.criticalpathtraining.com/ http://code.msdn.microsoft.com/msdnsp2010logdebug http://technet.microsoft.com/en-us/library/ee748619.aspx http://technet.microsoft.com/en-us/library/cc678870.aspx http://www.bing.com/search?q=sharepoint%20uls%20viewer http://msdn.microsoft.com/en-us/library/ff770300.aspx http://msdn.microsoft.com/en-us/library/ff798427.aspx http://msdn.microsoft.com/en-us/library/ff604025.aspx

http://msdn.microsoft.com/enus/library/microsoft.sharepoint.administration.spwebapplication.spcustompage.aspx
10 11

http://msdn.microsoft.com/en-us/library/ff512745.aspx

http://msdn.microsoft.com/enus/library/microsoft.sharepoint.webcontrols.developerdashboardlauncher.aspx http://msdn.microsoft.com/en-us/library/ee535537.aspx http://technet.microsoft.com/en-us/library/cc678868.aspx

12 13 14

http://www.shillier.com/archive/2010/08/05/Using-Business-Connectivity-Services-to-DisplaySharePoint-2010-ULS-Logs.aspx

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011

Debugging and Logging Capabilities in SharePoint 2010

Page 16 of 16

15 16 17

http://ulsviewer.codeplex.com/ http://msdn.microsoft.com/en-us/library/ff650022.aspx http://msdn.microsoft.com/sharepoint

Community Content
2011 Microsoft. All rights reserved.

http://msdn.microsoft.com/en-us/library/gg512103(d=printer).aspx

11/23/2011