The machine I’m working on has SQL Server Express. The Express version doesn’t come with the SQL Profiler. So without Profiler and without a log function on Entity Framework’s DbContext, what’s a developer to do?

Well, as it turns out, profiling is part of the SQL Server (any version, including Express), the SQL Profiler application is just one way to access the profiling functionality. Some people even argue it’s better to do the profiling on the server itself, as opposed to through SQL Profiler.

Starting the trace

How do you start? The easiest way to start is (you’re not going to like this) by using SQL Profiler. That’s what I did (on another machine). It’s explained on the website linked above, here are the steps:

1. Open up Profiler and create a new trace.
2. Select Save to File and select a location (it doesn’t matter where, we will be changing this). Select Enable File Rollover.
3. Choose your events and columns from the Events Selection tab.
4. Run the trace and then stop it right away.
5. From the File menu, choose Export > Script Trace Definition > For SQL Server 2005 (or whichever is appropriate in your environment) and save the script to file.
6. Open your file in SSMS, making sure you’re connected to the instance you want to profile.

This will yield a SQL script similar to the following:

/****************************************************/
/* Created by: SQL Server 2008 Profiler             */
/* Date: 10/13/2011  01:10:39 PM         */
/****************************************************/

-- Create a Queue
declare @rc int
declare @TraceID int
declare @maxfilesize bigint
set @maxfilesize = 5

-- Please replace the text InsertFileNameHere, with an appropriate
-- filename prefixed by a path, e.g., c:\MyFolder\MyTrace. The .trc extension
-- will be appended to the filename automatically. If you are writing from
-- remote server to local drive, please use UNC path and make sure server has
-- write access to your network share

exec @rc = sp_trace_create @TraceID output, 0, N'c:\SqlTrace\Trace', @maxfilesize, NULL
if (@rc != 0) goto error

-- Client side File and Table cannot be scripted

-- Set the events
declare @on bit
set @on = 1
exec sp_trace_setevent @TraceID, 11, 2, @on
exec sp_trace_setevent @TraceID, 11, 14, @on
exec sp_trace_setevent @TraceID, 11, 12, @on
exec sp_trace_setevent @TraceID, 13, 1, @on
exec sp_trace_setevent @TraceID, 13, 14, @on
exec sp_trace_setevent @TraceID, 13, 12, @on

-- Set the Filters
declare @intfilter int
declare @bigintfilter bigint

-- Set the trace status to start
exec sp_trace_setstatus @TraceID, 1

-- display trace id for future references
select TraceID=@TraceID
goto finish

error:
select ErrorCode=@rc

finish:
go

When you execute the above SQL in SQL Server Management Studio (SSMS), it will return one row of data with a column named “TraceID” (an integer). You’ll need this TraceID to stop the trace later on, so take note of it.

Stopping the trace

You can interact with the trace using the sp_trace_setstatus stored procedure. To stop the trace, execute the following SQL in SSMS and replace “@TraceID” with the number returned from the previous query.

exec sp_trace_setstatus @TraceID, 0

Delete the trace definition

Stopping the trace doesn’t delete it. By deleting I don’t mean to delete the trace file (like “c:\SqlTrace\Trace” in the query above), but deleting this trace’s definition from the SQL server. The following query will delete the trace from the SQL server (again, replace “@TraceID” with the trace ID you got from executing the first query mentioned above):

exec sp_trace_setstatus @TraceID, 2

Read from the trace

If the above went well, you will now have a trace file (like c:\SqlTrace\Trace.trc). If you open it in NotePad, you’ll notice it’s not in a plain text or other readable format. So how can you read from the trace without needing SQL Server Profiler? Pretty simple, using fn_trace_gettable. Execute the following query in SSMS to read from the trace file:

SELECT *
FROM ::fn_trace_gettable('c:\SqlTrace\Trace.trc', default)

Oops, forgot the Trace ID?

Don’t worry, run the fn_trace_getinfo function. The first column lists all existing TraceIDs.

SELECT * FROM ::fn_trace_getinfo(0)

And that’s it! You can now profile any SQL Server version, be it Express, Standard or Enterprise, without using SQL Profiler.

try
{
    // do stuff
}
catch (Exception ex)
{
    string soapExceptionDetail = string.empty;
    if (ex is SoapException)
    {
        soapExceptionDetail =
            string.Format(
                "\nSoapException Detail: {0}\n",
                ((SoapException)ex).Detail.InnerText
            );
    }
    throw new InvalidPluginExecutionException(
        string.Format(
            "An error occurred in the {0} plug-in.{1}",
            this.GetType().ToString(), soapExceptionDetail
        ),
        ex
    );
}

Now sometimes, property names promise a bit too much. Because the error I was getting in the SoapException.Detail was the anything but helpful “Generic SQL Error” (0×80044150 or 2147762512). That could be anything. By the way, the following is the SQL query I’m running on the WorkflowLog view of the organization’s Dynamics CRM database. It will only show the ones with an ErrorCode, sorted by newest date first.

SELECT TOP 1000
  [AsyncOperationIdName]
  ,[Description]
  ,[Message]
  ,[CreatedOn]
  ,[ModifiedOn]
  ,[CompletedOn]
  ,[StepName]
  ,[Status]
  ,[ErrorCode]
  ,[ActivityName]
FROM [WorkflowLog]
WHERE ErrorCode IS NOT NULL
ORDER BY ModifiedOn DESC, StepName DESC

We’re looking at the “Message” column of data here. If a plugin throws an InvalidPluginExecutionException, you’ll find the error message (provided you’ve entered one) and the stack trace (also of any inner exceptions) in this database field. Neat! But… “Generic SQL Error” won’t get us any closer to a solution.

Next, you’ll want to switch on tracing/logging for Dynamics CRM. For MS Dynamics CRM 4, this will put the trace in the following folder: Drive:\Program Files\Microsoft Dynamics CRM\Trace. I tend to restart IIS and the CrmAsyncService after such a change.

There will be trace logs created with names like servername-crmasyncservice-bin-20110922-1.log or servername-w3wp-wwwroot-20110922-1.log. Since my custom workflows are running asynchronously, I’m first interested in the CrmAsyncService log. Pretty quickly, I could find stuff like this:

[2011-09-20 05:28:12.1] Process:CrmAsyncService |Organization:7a8005ba-c6b4-4fc7-8ba0-82a57dd75a6e |Thread:   46 |Category: Platform.Async |User: 00000000-0000-0000-0000-000000000000 |Level: Error | AsyncOperationCommand.Execute
>Exception while trying to execute AsyncOperationId: {B7627B65-38E3-E011-A4C1-000C29D1C68A} AsyncOperationType: 1 - System.Data.SqlClient.SqlException: Transaction (Process ID 71) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.
   at Valx.Crm.Plugins.UpdateKitProduct.UpdateKitProductPlugin.Execute(IPluginExecutionContext context)
   at Microsoft.Crm.Asynchronous.EventOperation.InternalExecute(AsyncEvent asyncEvent)
   at Microsoft.Crm.Asynchronous.AsyncOperationCommand.Execute(AsyncEvent asyncEvent)

Alright, database deadlocks! We’re pounding that poor SQL Server too hard… Poor thing. Now in my opinion there are two obvious solutions: reduce the number of parallel/concurrent threads of the CrmAsyncService, or start throttling the database queries (or the CrmService calls). Since reducing the number of parallel/concurrent threads of the Crm Asynchronous Service is not really well-documented, I chose to look into throttling.

First, I make the assumption that, when the workflow catches a SoapException that mentions a “Generic SQL Error” in its Detail, it is a SQL deadlock. That’s why you need to check the trace for the actual SQL error. But as far as I could tell, in my trace log files of a couple of days, the only SQL errors were of the kind “chosen as the deadlock victim”.

Dynamics CRM 4 already has a mechanism for recovering from SQL errors, both for plugins and workflows. But! You cannot throw a SQLException from a SoapException. As you can see on the above-linked page, a workflow will undoubtedly fail after throwing a InvalidPluginExecutionException. After some experimenting, I devised the following methods. These are extension methods for the ICrmService and what they do is simple: if the call fails with a SoapException and the SoapException.Detail contains the text “generic sql error”, it will retry, but only after waiting. Now the waiting time is extended for each iteration. I chose 1 second times the number of iterations, you can choose so at will.

The wait is implemented using a Thread.Sleep(). That might not always be good, but in this case it’s great, because it will prevent spawning more threads by the asynchronous CRM service, thus creating some breathing space for this waiting thread.

Here are the extension methods:

using System;
using Microsoft.Crm.Sdk;
using Microsoft.Crm.SdkTypeProxy;

namespace Broes.Crm.Workflows
{
    public static class CrmServiceExtensions
    {
        /// <summary>
        /// Method to execute a Request on the given ICrmService.
        /// When the CrmService throws a SoapException
        /// which points to a SQL Server error,
        /// it most probably is a deadlock. Subsequently,
        /// this method will sleep the current Thread
        /// for a short while and then retry. It will retry for
        /// a maximum of five times, each time with a
        /// greater interval.
        /// </summary>
        /// <typeparam name="T">The Response type, e.g. RetrieveResponse.</typeparam>
        /// <param name="crmService">The ICrmService to connect to the CRM.</param>
        /// <param name="request">The Request to execute on the CRM service.</param>
        /// <returns>The Response object.</returns>
        public static T ExecuteWithRetry<T>(this ICrmService crmService, Request request)
            where T : Response
        {
            T response = null;
            int i = 0;

            // Maximum of five iterations.
            while (i < 5)
            {
                try
                {
                    response = (T)crmService.Execute(request);

                    // If the Execute does not throw an Exception, break the loop
                    break;
                }
                catch (System.Web.Services.Protocols.SoapException e)
                {
                    // Retry if the SoapException is a "Generic SQL Error",
                    // otherwise rethrow the SoapException.
                    // "Generic SQL Error" might indicate a deadlock.
                    if (e.Detail.InnerText.ToLower().Contains("generic sql error"))
                    {
                        ++i;
                        // Wait (sleep thread) for i * 1000 milliseconds.
                        // So, first iteration waits 1 second,
                        // while fifth iteration will wait 5 seconds.
                        System.Threading.Thread.Sleep(i * 1000);
                    }
                    else throw;
                }
            }

            if (i >= 5)
            {
                throw new Exception("CrmServiceExtensions.ExecuteWithRetry: too many retries");
            }

            return response;
        }

        /// <summary>
        /// Method to execute a Fetch XML on a given ICrmService.
        /// When the CrmService throws a SoapException
        /// which points to a SQL Server error,
        /// it most probably is a deadlock. Subsequently,
        /// this method will sleep the current Thread
        /// for a short while and then retry. It will retry
        /// for a maximum of five times, each time with a
        /// greater interval.
        /// </summary>
        /// <param name="crmService">The ICrmService to connect to the CRM.</param>
        /// <param name="fetchXml">The Fetch XML to execute.</param>
        /// <returns>The result string of the Fetch method.</returns>
        public static string FetchWithRetry(this ICrmService crmService, string fetchXml)
        {
            string fetchXmlResponse = string.Empty;
            int i = 0;

            while (i < 5)
            {
                try
                {
                    fetchXmlResponse = crmService.Fetch(fetchXml);

                    // If the Fetch does not throw an exception, break the while-loop.
                    break;
                }
                catch (System.Web.Services.Protocols.SoapException e)
                {
                    // Retry if the SoapException is a "Generic SQL Error",
                    // otherwise rethrow the SoapException.
                    // "Generic SQL Error" might indicate a deadlock.
                    if (e.Detail.InnerText.ToLower().Contains("generic sql error"))
                    {
                        ++i;
                        // Sleep the current thread for i * 1000 milliseconds
                        System.Threading.Thread.Sleep(i * 1000);
                    }
                    else throw;
                }
            }

            if (i >= 5)
            {
                throw new Exception("CrmServiceExtensions.ExecuteWithRetry: too many retries");
            }

            return fetchXmlResponse;
        }
    }
}

Hope this helps sharing with you, because I found a ton of users battling the “Generic SQL Error” and “deadlock victim” errors in (asynchronous) plugins and workflows, but so far have not seen anyone creating a possible solution.

Well, I didn’t think this follow-up to Part 1 would come this quick, but here it is! Again I would like to emphasize that Jan Hoefnagels is the one who should take credit for this solution, but he isn’t the blog-writing type of guy. He’s not even a “Getting Things Done” guy. He’s a “Making Things Work” guy. And he’s pretty good at that.

Anyway, Part 1 showed you a general solution for an implementation of a Rendering Extension for SQL Server Reporting Services that was able to utilize the built-in (Microsoft provided) PDF Renderer, while enabling you to get the rendered PDF and do “something” with it, before sending it back to the SSRS server, which would subsequently send it to the end-user as a downloadable PDF file. That was a long sentence by English standards, but by Dutch standards, that’s kind of like a normal length. In German however, you would just be getting started. This whole article could be one sentence in German and still leave room for more.

Stay focussed. Now this “something” would be: adding a so-called watermark or background to the PDF of the rendered result. And this background would be another PDF file, like the corporate letter design. This would retain e.g. embedded fonts and vector-based images, like the company logo. Yes, we’re those guys that are anal about quality, and bitmap just doesn’t cut it for us.

What has changed since the last post is the need to make the solution as dependency-free as possible. I don’t dare to use the words “Inversion of Control”, since I haven’t got the slightest idea what they mean, but I just did. It was more like: how can we create the Rendering Extension in such a way that we can set the PDF used as a background without rebuilding the extension? So it’s more about configurability. Maybe some IoC as well. What do I know…

We cooked up two points of entry for configuration and I’m sure there are more to find:

• In the DeviceInfo of the RSReportServer.config file.
• In the Report.Parameters

OK, you might ask, so where do I put the PDF with the background design? Well, just add it to the Report Server using the Report Manager (hint: http://<reportserver:port>/Reports )!
Because the Report class has a helper function public bool GetResource(string resourcePath, out byte[] resource, out string mimeType), you are able to retrieve a resource on the report server, using a resourcePath that can either be relative to the report, or absolute to the report server. When you’re using the Report Manager, you can see the path to the current folder or file in the URL, it’s the itemPath parameter. It’s UrlEncoded, by the way, so those %2F are actually forward slashes /.

I could go on for hours, but let me just give you the updated code. It’s using ITextSharp, based on IText, which is an open-source PDF library, but not necessarily free. So much for IoC by the way. Ah well, this was merely a “proof of concept”, right?

using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Text;
using Microsoft.ReportingServices.OnDemandReportRendering;
using ImageRenderer = Microsoft.ReportingServices.Rendering.ImageRenderer;
using Interfaces = Microsoft.ReportingServices.Interfaces;

namespace Broes.ReportRendering.PDF
{

    // The "PDF with background PDF renderer" for SQL Server Reporting Services.
    public class PdfWithBackgroundRenderer : IRenderingExtension
    {
        // The built-in PDF renderer we're gonna use later.
        private ImageRenderer.PDFRenderer pdfRenderer;

        // Stream to capture the result of the PDF renderer later.
        private Stream intermediateStream;

        // Fields for maintaining state.
        private string _name;
        private string _extension;
        private Encoding _encoding;
        private string _mimeType;
        private bool _willSeek;
        private Interfaces.StreamOper _operation;

        // Default constructor
        public PdfWithBackgroundRenderer()
        {
            // Initialize the PDF renderer.
            pdfRenderer = new ImageRenderer.PDFRenderer();
        }

        // Intermediate CreateAndRegisterStream method that matches the delegate
        // Microsoft.ReportingServices.Interfaces.CreateAndRegisterStream
        // It will return a reference to a new MemoryStream, so we can get to
        // the results of the intermediate render-step later.
        public Stream IntermediateCreateAndRegisterStream(
            string name,
            string extension,
            Encoding encoding,
            string mimeType,
            bool willSeek,
            Interfaces.StreamOper operation)
        {
            _name = name;
            _encoding = encoding;
            _extension = extension;
            _mimeType = mimeType;
            _operation = operation;
            _willSeek = willSeek;

            // Create and return a new MemoryStream,
            // which will contain the results of the PDF renderer.
            intermediateStream = new MemoryStream();
            return intermediateStream;
        }

        // This method will be called by Reporting Services
        // when it executes a request to render a report
        // using this renderer.
        public bool Render(Report report,
            NameValueCollection reportServerParameters,
            NameValueCollection deviceInfo,
            NameValueCollection clientCapabilities,
            ref Hashtable renderProperties,
            Interfaces.CreateAndRegisterStream createAndRegisterStream)
        {
            // Let the built-in PDF renderer do the hard work!
            // After this call, the rendered PDF will be in the intermediateStream.
            // We're just passing-through the Render parameters.
            pdfRenderer.Render(
                report,
                reportServerParameters,
                deviceInfo,
                clientCapabilities,
                ref renderProperties,
                // This is the tricky part: get a delegate method to send a stream to the
                // PDF renderer, while keeping a reference to the same stream.
                // (See the IntermediateCreateAndRegisterStream method above).
                new Interfaces.CreateAndRegisterStream(IntermediateCreateAndRegisterStream)
            );

            // This is the actual Stream which Reporting Services uses
            // to send the result to the end-user.
            Stream outputStream =
                createAndRegisterStream(_name, _extension, _encoding, _mimeType, _willSeek, _operation);

            // It took us some time to figure out why the intermediateStream,
            // while having a length, always returned an empty result upon
            // reading from it. Well, after writing to the MemoryStream,
            // the PDF renderer doesn't reset the stream's position, so
            // we have to.
            intermediateStream.Position = 0;

            // A byte buffer for the background PDF.
            byte[] backgroundContent;
            // This will contain the mime-type of the background PDF.
            string backgroundType;

            // To be able to configure which background PDF to
            // use from the report designer, you could use a report parameter
            // like 'BackgroundPdfPath'. You can then store the PDF on the
            // Report Server itself!
            // The path to the PDF should be relative to the report,
            // e.g. "../Background.pdf" or absolute to the server,
            // e.g. "/Sales/Quote/Background.pdf".
            ReportParameter pdfPath = null;
            try
            {
                pdfPath = report.Parameters["BackgroundPdfPath"];
            }
            catch
            { }

            // Check if there actually was a path to the background PDF.
            if (
                pdfPath != null // ReportParameter is not null
                && pdfPath.Instance != null // ... and its instance is not null
                && !string.IsNullOrEmpty((string)pdfPath.Instance.Value) // ... and its value is not null
                // The GetResource method of a Report is able to get any resource
                // available on the Report Server a relative or absolute path.
                // The contents of the resource are in the 'backgroundContent' byte buffer,
                // while the mime-type is in the 'backgroundType' string.
                && report.GetResource((string)pdfPath.Instance.Value, out backgroundContent, out backgroundType))
            {
                // Pass the contents of the resource to the AddBackgroundPdf helper
                // method.
                // Notice that we just assume it is a PDF. Wanna be more certain?
                // Check the mime-type in the 'backgroundType' string.
                intermediateStream = PdfHandler.AddBackgroundPdf(intermediateStream, new MemoryStream(backgroundContent));
            }
            // There was no path to a background PDF in the report
            // parameters, so we fall back to the deviceInfo.
            // DeviceInfo is configurable in the RSReportServer.config file, see
            // http://msdn.microsoft.com/en-us/library/ms156281.aspx
            // This way, you could set a default background PDF if it isn't
            // specified in the report parameters. Configurability FTW!
            else if (
                deviceInfo.AllKeys.Contains("BackgroundPdfResourcePath")
                && !string.IsNullOrEmpty(deviceInfo["BackgroundPdfResourcePath"])
                && report.GetResource(deviceInfo["BackgroundPdfResourcePath"], out backgroundContent, out backgroundType))
            {
                intermediateStream = PdfHandler.AddBackgroundPdf(intermediateStream, new MemoryStream(backgroundContent));
            }

            // A buffer for copying the intermediateStream to the outputStream
            // http://stackoverflow.com/questions/230128/best-way-to-copy-between-two-stream-instances-c
            byte[] buffer = new byte[32768];

            // Do the actual copying.
            while (true)
            {
                int read = intermediateStream.Read(buffer, 0, buffer.Length);
                if (read <= 0) break;
                outputStream.Write(buffer, 0, read);
            }

            // Be nice and release some hard-needed resources.
            intermediateStream.Close();
            intermediateStream = null;

            // Return false, because:
            // "A return value of true indicates that any properties added
            // to the report object model are saved into the intermediate format."
            // http://msdn.microsoft.com/en-us/library/microsoft.reportingservices.reportrendering.irenderingextension.render(SQL.90).aspx
            // ... and we're obviously not doing that, are we? Are we? ARE WE?
            return false;
        }

        public bool RenderStream(
            string streamName,
            Report report,
            NameValueCollection reportServerParameters,
            NameValueCollection deviceInfo,
            NameValueCollection clientCapabilities,
            ref Hashtable renderProperties,
            Interfaces.CreateAndRegisterStream createAndRegisterStream)
        {
            // We'll implement this "later". No, seriously.
            return false;
        }

        public string LocalizedName
        {
            // Just say what it is. In English. That's one localization...
            get { return "PDF with background"; }
        }

        public void SetConfiguration(string configuration)
        {
            // Did I tell you this is another place
            // where you could receive configuration options?
            // Check out:
            // http://msdn.microsoft.com/en-us/library/microsoft.reportingservices.interfaces.iextension.setconfiguration.aspx
        }

        public void GetRenderingResource(
            Interfaces.CreateAndRegisterStream createAndRegisterStreamCallback,
            NameValueCollection deviceInfo)
        {
            // We'll implement this "later" as well. Still don't believe me?
            // Then you've got some serious trust issues!
        }
    }
}

And of course the PdfHandler class referenced above.

using System.IO;
using iTextSharp.text;
using iTextSharp.text.pdf;

namespace Broes.ReportRendering.PDF
{
    // Utility class to handle PDF's, obviously.
    // Uses the open source component iTextSharp:
    // http://itextsharp.com/
    public static class PdfHandler
    {
        // One method to rule them all. Since it's the only one, that is.
        public static Stream AddBackgroundPdf(Stream existingDocumentStream, Stream backgroundStream)
        {
            // This stream will hold the new (merged) document
            MemoryStream documentWithBackground = new MemoryStream();

            // Initialize a new PDF document
            Document newDocument = new Document();

            // Initialize a new PDF stream writer
            PdfWriter writer = PdfWriter.GetInstance(newDocument, documentWithBackground);

            // Initialize the background PDF stream reader
            PdfReader backgroundReader = new PdfReader(backgroundStream);

            // Initialize the existing PDF stream reader
            PdfReader reader = new PdfReader(existingDocumentStream);

            // Set the page size of the merged document to the
            // size of the first page of the existing document.
            newDocument.SetPageSize(reader.GetPageSize(1));

            // Opening the document allows you to start writing content to it,
            // but you will no longer be able to add header- or meta-information.
            newDocument.Open();

            // Get access to the contents of the writer
            PdfContentByte newContent = writer.DirectContent;

            // Get the y-offset of the background PDF with regard to the
            // existing PDF, considering its page size.
            // PDF always starts at the bottom left, and we want the
            // background to always start at the top left.
            float yDistance = 0;
            if (backgroundReader.GetPageSize(1).Height > reader.GetPageSize(1).Height)
            {
                yDistance = reader.GetPageSize(1).Height - backgroundReader.GetPageSize(1).Height;
            }

            // Clean up some resources.
            backgroundReader.Close();

            // Only import the first page from the background PDF
            PdfImportedPage backgroundPage = writer.GetImportedPage(backgroundReader, 1);

            // Merge each page of the existing PDF with the background PDF
            for (int i = 1; i <= reader.NumberOfPages; i++)
            {
                // Create the page
                newDocument.NewPage();
                // Add the contents of the first page of the background PDF to
                // the current page, using the y-offset.
                newContent.AddTemplate(backgroundPage, 0, yDistance);
                // Import the current page of the existing PDF.
                PdfImportedPage existingPage = writer.GetImportedPage(reader, i);
                // Add the contents of the existingPage to the current page.
                newContent.AddTemplate(existingPage, 0, 0);
            }

            // Clean up some resources.
            newDocument.Close();
            reader.Close();

            // Close the writer to properly finish the PDF document.
            // http://api.itextpdf.com/com/itextpdf/text/pdf/PdfWriter.html#close()
            writer.Close();

            // UPDATE 2011-02-22:
            // The following doesn't work, as the underlying Stream also
            // closes when you call PdfWriter.Close().
            // -- Reset the position of the MemoryStream,
            // so the next consumer will find it ready to go.
            // documentWithBackground.Position = 0; --

            // UPDATE 2011-02-22:
            // After closing the MemoryStream, it is still
            // possible to copy the contents of its underlying
            // buffer using ToArray() to a new Stream.
            return new MemoryStream(documentWithBackground.ToArray());
        }
    }
}

And that kind of wraps it up. When you want to roll this into your own Rendering Extension, don’t forget to “Strong Name” your assembly.
You’ll need the assembly’s “Public Key Blob”, which you can find by running (from the Visual Studio Command Prompt) sn -Tp [pathToAssembly]\[assemblyFileName]. This post explains how you can roll the command into the VS Tools menu.
After that, you need to update two config files: rssrvpolicy.config and rsreportserver.config. Both are located under (by default) C:\Program Files\Microsoft SQL Server\MSRS10.MSSQLSERVER\Reporting Services\ReportServer

The least hard is editing the rsreportserver.config file, and this is pretty well-documented on this page.

Editing the rssrvpolicy.config file however is a pain in the @$ß. Again, it is “documented” right here (seriously, I feel so dumb reading stuff like that). Let’s just look at an example entry:

<CodeGroup class="UnionCodeGroup" version="1" PermissionSetName="FullTrust" Name="SharePoint_Server_Strong_Name" Description="This code group grants SharePoint Server code full trust. ">
    <IMembershipCondition class="StrongNameMembershipCondition" version="1" PublicKeyBlob="0024000004800000940000000602000000240000525341310004000001000100AFD4A0E7724151D5DD52CB23A30DED7C0091CC01CFE94B2BCD85B3F4EEE3C4D8F6417BFF763763A996D6B2DFC1E7C29BCFB8299779DF8785CDE2C168CEEE480E570725F2468E782A9C2401302CF6DC17E119118ED2011937BAE9698357AD21E8B6DFB40475D16E87EB03C744A5D32899A0DBC596A6B2CFA1E509BE5FBD09FACF" />
</CodeGroup>

I would recommend just mimicking such an entry. Make up a name and description and copy the PublicKeyBlob you got from the sn -Tp command referenced above.

Finally, copy your DLL (and PDB?) as well as iTextPdf’s DLL to the Reporting Services’ Report Server’s bin directory, which by default is located at C:\Program Files\Microsoft SQL Server\MSRS10.MSSQLSERVER\Reporting Services\ReportServer\bin.

Update 2011-02-23: If you want to debug the assembly in Visual Studio 2010, you need to follow these instructions.

Don’t forget to restart the “SQL Server Reporting Services (INSTANCENAME)” under “Services”!

Keep a close eye on the Application Log in the Event Viewer. When something’s wrong, SSRS will start whining right there.

And that’s it! As you can see, sentences got a whole lot shorter while nearing the end of this post. I guess the sentence-length kind of reflects my state of mind, which now screams “exhaustion”! Good night (and yes, I realize that the chances someone else is reading this right before going to bed are rather slim)!

We promised our client quotes, orders and invoices —as generated by SQL Server Reporting Services, which is neatly integrated into Dynamics CRM— with and without their own letter background, so they could use the same reports for printing on pre-printed paper (no background), as well as send the PDF through email to their clients (with background).

Sounds like a logical, real-world proposition, right? So the only thing we needed to do is create a report that has a background that can be enabled/disabled. SSRS supports background-images, but as we soon found out, the actual DPI (or PPI since it’s a bitmap) of the image is neglected. Image rendering in SSRS is hard-coded at 72 96DPI. Not only that, it will assume the original image is 96DPI, so a 300DPI image will end up being rendered appr. 3.1 times larger than expected!

And even more so, why would I want to include a bitmap image of something I already have laying around as a vector file (namely a PDF)? It will only add up to the file size and decrease it’s quality.
So the search begins, for “something” that would allow us to add a PDF background “on the fly” to a report exported as PDF from the report viewer in Dynamics CRM. As it turned out, lot’s of people searching for it, but no conclusive answer or solution (hence this post).

We wanted it to be as integrated and reusable as possible for ourselves, as well as transparent to the end-user. Enter the world of Rendering Extensions. It’s a typical Microsoft world where the documentation on MSDN lists all classes and -members (the “what”), but fails to explain the “how”. I’m sure it will improve over time (as has been the case with the Dynamics CRM 4.0 documentation), but when you need it NOW, well, look further. By the way, this is what MSDN says about implementing your own rendering extension:

Writing a custom rendering extension is difficult. A rendering extension must typically support all possible combinations of report elements and requires that you implement hundreds of classes, interfaces, methods, and properties.

Gee, thanks for the warning! But I don’t want that! I just want to add a PDF background… I still want to use Microsoft’s PDF rendering extension and then add the background.

Jan is not a guy to say: hey, let’s just leave it at that. He’s more the kind of guy that says: I can do that. If some Microsoft engineer can do it, I can do it. So he did the plumbing to create a rendering extension (implementing IRenderingExtension), registering it in SSRS… and then ground to a halt. He got it so far as to output the Report parameters to a plain text result. And it did show up as an export option in the Dynamics CRM report viewer!

So we sat together and step-by-step came to the following result (I’ll explain afterwards) that will actually… do exactly the same thing as the built-in PDF renderer! But as you will soon see, it allows you to do “something” with the result from the built-in PDF renderer, before sending it to the end-user. Which is kind-of exactly what we want to do.

using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Text;
using Microsoft.ReportingServices.OnDemandReportRendering;
using ImageRenderer = Microsoft.ReportingServices.Rendering.ImageRenderer;
using Interfaces = Microsoft.ReportingServices.Interfaces;

namespace Broes.ReportRendering.PDF
{

    public class PdfWithBackgroundRenderer : IRenderingExtension
    {
        // The built-in PDF renderer we're gonna use later.
        private ImageRenderer.PDFRenderer pdfRenderer;

        // Stream to capture the result of the PDF renderer later.
        private Stream intermediateStream;

        // Fields for maintaining state.
        private string _name;
        private string _extension;
        private Encoding _encoding;
        private string _mimeType;
        private bool _willSeek;
        private Interfaces.StreamOper _operation;

        // Default constructor
        public PdfWithBackgroundRenderer()
        {
            // Initialize the PDF renderer.
            pdfRenderer = new ImageRenderer.PDFRenderer();
        }

        // Intermediate CreateAndRegisterStream method that matches the delegate
        // Microsoft.ReportingServices.Interfaces.CreateAndRegisterStream
        // It will return a reference to a new MemoryStream, so we can get to
        // the results of the intermediate render-step later.
        public Stream IntermediateCreateAndRegisterStream(
            string name,
            string extension,
            Encoding encoding,
            string mimeType,
            bool willSeek,
            Interfaces.StreamOper operation)
        {
            _name = name;
            _encoding = encoding;
            _extension = extension;
            _mimeType = mimeType;
            _operation = operation;
            _willSeek = willSeek;

            // Create and return a new MemoryStream,
            // which will contain the results of the PDF renderer.
            intermediateStream = new MemoryStream();
            return intermediateStream;
        }

        public bool Render(Report report,
            NameValueCollection reportServerParameters,
            NameValueCollection deviceInfo,
            NameValueCollection clientCapabilities,
            ref Hashtable renderProperties,
            Interfaces.CreateAndRegisterStream createAndRegisterStream)
        {

            // Let the built-in PDF renderer do the hard work!
            // After this call, the rendered PDF will be in the intermediateStream.
            // We're just passing-through the Render parameters.
            pdfRenderer.Render(
                report,
                reportServerParameters,
                deviceInfo,
                clientCapabilities,
                ref renderProperties,
                // This is the tricky part: get a delegate method to send a stream to the
                // PDF renderer, while keeping a reference to the same stream.
                // (See the IntermediateCreateAndRegisterStream method above).
                new Interfaces.CreateAndRegisterStream(IntermediateCreateAndRegisterStream)
            );

            // This is the actual Stream which Reporting Services uses
            // to send the result to the end-user.
            Stream outputStream =
                createAndRegisterStream(_name, _extension, _encoding, _mimeType, _willSeek, _operation);

            // It took us some time to figure out why the intermediateStream,
            // while having a length, always returned an empty result upon
            // reading from it. Well, after writing to the MemoryStream,
            // the PDF renderer doesn't reset the stream's position, so
            // we have to.
            intermediateStream.Position = 0;

            // A buffer for copying the intermediateStream to the outputStream
            // http://stackoverflow.com/questions/230128/best-way-to-copy-between-two-stream-instances-c
            byte[] buffer = new byte[32768];

            // Do the actual copying.
            // While the streams are copying, think of the
            // possibilities: this is the place where you would
            // be able to fire up that external PDF library
            // and add the PDF background!
            // But don't think too long, cause' computers are pretty fast
            // these days and will probably have finished copying this
            // stream by the time you even got to start reading.
            while (true)
            {
                int read = intermediateStream.Read(buffer, 0, buffer.Length);
                if (read <= 0) break;
                outputStream.Write(buffer, 0, read);
            }

            // Be nice and release some hard-needed resources.
            intermediateStream.Close();

            // Return false, because:
            // "A return value of true indicates that any properties added
            // to the report object model are saved into the intermediate format."
            // http://msdn.microsoft.com/en-us/library/microsoft.reportingservices.reportrendering.irenderingextension.render(SQL.90).aspx
            // ... and we're obviously not doing that, are we? Are we? ARE WE?
            return false;
        }

        public bool RenderStream(
            string streamName,
            Report report,
            NameValueCollection reportServerParameters,
            NameValueCollection deviceInfo,
            NameValueCollection clientCapabilities,
            ref Hashtable renderProperties,
            Interfaces.CreateAndRegisterStream createAndRegisterStream)
        {
            // We'll implement this "later". No, seriously.
            return false;
        }

        public string LocalizedName
        {
            // Just say what it is. In English. That's one localization...
            get { return "PDF with background"; }
        }

        public void SetConfiguration(string configuration)
        {
            // Had there been configuration options,
            // we would do something with them here.
            // Like, for instance, the path to the PDF file
            // you want to use as a background.
        }

        public void GetRenderingResource(
            Interfaces.CreateAndRegisterStream createAndRegisterStreamCallback,
            NameValueCollection deviceInfo)
        {
            // We'll implement this "later" as well. Still don't believe me?
            // Then you've got some serious trust issues!
        }

    }
}

What more is there to explain? If you would use a component like ABCpdf you could use something similar to Read(Stream stream) to open the intermediateStream and add a background/watermark.
After you’ve done that, get the component to return the edited PDF as a Stream and copy the contents of this Stream to the outputStream.

When we’re done implementing this extension for the client, I’ll post a Part 2! How about that for a cliffhanger!

• KNMI’s “Neerslagradar”
• Buienradar’s “Sneeuwradar”!

Download versie 2.4!

Download de Brandstofprijzen widget en vergeet niet je commentaar achter te laten!

Daarom is de widget nu ge-update (naar versie 1.1), zodat deze weer werkt.

Download de Brandstofprijzen widget en vergeet niet je commentaar achter te laten!

Zo kan er zo snel mogelijk weer gebruik worden gemaakt van de NL Weerradar widget onder Snow Leopard!

Die is er nu voor Mac OS X Dashboard: de Brandstofprijzen Widget.

Geef de postcode, de afstand en het brandstoftype op en de widget haalt de gegevens op en presenteert de resultaten overzichtelijk. Bladeren door de resultaten gaat d.m.v. de knopjes onderaan. Klikken op het adres opent de locatie op Google Maps. De resultaten zijn voorzien van de logo’s van de bekende tankstations.

De ingevoerde gegevens en de laatste zoekresultaten worden bewaard, zodat deze ook na een herstart van de computer of de widget direct beschikbaar zijn.

Downloaden van de widget en commentaar op de pagina van de Brandstofprijzen Widget!

Download version 1.5 of the Euro Stocks widget.

For comments, please go to the Euro Stocks widget’s page!

Enjoy!

Note to users who update. Please write down the codes of your indices/stocks/funds before you update! Due to a design decision made earlier (to allow multiple instances of the widget, all with their own preferences) and the fact that Apple doesn’t provide a way to keep the unique widgetID between updates, the preferences of your widget won’t be retained between updates.