Log HTML Conversion Time in C#

To log HTML conversion time in C#, add custom message handlers to the Aspose.HTML for .NET pipeline: one handler resolves resources from a ZIP archive, while paired logging handlers measure request execution time before rendering the document to PDF.

Performance diagnostics often start with one question: how long does the loading and rendering workflow take? In this example, custom message handlers are chained together to convert an HTML-based file from a ZIP archive to PDF and log the request execution time.

Build the Logging Pipeline

Create a Message Handler for a Custom Schema

First, create a handler that can participate in a custom schema or protocol implementation. Take the following steps:

1. Use the necessary Namespace, which is the Aspose.Html.Net.
2. Define your own CustomSchemaMessageHandler class derived from the MessageHandler class.
3. Initialize an instance of the CustomSchemaMessageHandler class and define a Filter property for it.
4. Create the CustomSchemaMessageFilter class derived from the MessageFilter class.
5. Override the Match() method of the MessageFilter class to implement the custom message handler behaviour.

The following code snippet shows how to create the CustomSchemaMessageHandler class:

// Monitor network requests by custom protocol in C # using schema-based message filter and handler

// Define the CustomSchemaMessageFilter class that is derived from the MessageFilter class
class CustomSchemaMessageFilter : MessageFilter
{
    private readonly string schema;
    public CustomSchemaMessageFilter(string schema)
    {
        this.schema = schema;
    }
    // Override the Match() method
    public override bool Match(INetworkOperationContext context)
    {
        return string.Equals(schema, context.Request.RequestUri.Protocol.TrimEnd(':'));
    }
}

// Define the CustomSchemaMessageHandler class that is derived from the MessageHandler class
abstract class CustomSchemaMessageHandler : MessageHandler
{
    // Initialize an instance of the CustomSchemaMessageHandler class
    protected CustomSchemaMessageHandler(string schema)
    {
        Filters.Add(new CustomSchemaMessageFilter(schema));
    }
}

The CustomSchemaMessageHandler(schema) constructor instantiates the CustomSchemaMessageHandler object and takes schema as a parameter. The Add() method appends the CustomSchemaMessageFilter object at the end of the collection. The Match() method tests whether a context satisfies the filter criteria.

Create ZipFileSchemaMessageHandler for ZIP Archives

The following code snippet shows how to create the ZipFileSchemaMessageHandler class for working with ZIP archives:

// Handle zip file protocol requests in c#

// Define the ZipFileSchemaMessageHandler class that is derived from the CustomSchemaMessageHandler class
class ZipFileSchemaMessageHandler : CustomSchemaMessageHandler
{
    private readonly Archive archive;

    public ZipFileSchemaMessageHandler(Archive archive) : base("zip-file")
    {
        this.archive = archive;
    }

    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        string pathInsideArchive = context.Request.RequestUri.Pathname.TrimStart('/').Replace("\\", "/");
        Stream stream = GetFile(pathInsideArchive);

        if (stream != null)
        {
            // If a resource is found in the archive, then return it as a Response
            ResponseMessage response = new ResponseMessage(HttpStatusCode.OK);
            response.Content = new StreamContent(stream);
            response.Headers.ContentType.MediaType = MimeType.FromFileExtension(context.Request.RequestUri.Pathname);
            context.Response = response;
        }
        else
        {
            context.Response = new ResponseMessage(HttpStatusCode.NotFound);
        }

        // Invoke the next message handler in the chain
        Next(context);
    }

    Stream GetFile(string path)
    {
        ArchiveEntry result = archive
            .Entries
            .FirstOrDefault(x => x.Name == path);
        return result?.Open();
    }
}

In the above example, searching for a resource (zip archive) at its URI is realized. If a resource is found, FromFileExtension() method returns the MimeType of the resource.

Create Message Handlers for Request Duration Logging

The following code snippet shows how to create StartRequestDurationLoggingMessageHandler and StopRequestDurationLoggingMessageHandler to log the time taken for web request execution.

// Track and log HTTP request durations using C# message handlers

// Define the RequestDurationLoggingMessageHandler class that is derived from the MessageHandler class
abstract class RequestDurationLoggingMessageHandler : MessageHandler
{
    private static ConcurrentDictionary<Url, Stopwatch> requests = new ConcurrentDictionary<Url, Stopwatch>();

    protected void StartTimer(Url url)
    {
        requests.TryAdd(url, Stopwatch.StartNew());
    }

    protected TimeSpan StopTimer(Url url)
    {
        Stopwatch timer = requests[url];
        timer.Stop();
        return timer.Elapsed;
    }
}

class StartRequestDurationLoggingMessageHandler : RequestDurationLoggingMessageHandler
{
    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Start the stopwatch
        StartTimer(context.Request.RequestUri);

        // Invoke the next message handler in the chain
        Next(context);
    }
}

class StopRequestDurationLoggingMessageHandler : RequestDurationLoggingMessageHandler
{
    // Override the Invoke() method
    public override void Invoke(INetworkOperationContext context)
    {
        // Stop the stopwatch
        TimeSpan duration = StopTimer(context.Request.RequestUri);

        // Print the result
        Debug.WriteLine($"Elapsed: {duration:g}, resource: {context.Request.RequestUri.Pathname}");

        // Invoke the next message handler in the chain
        Next(context);
    }
}

Add the Message Handlers to the Pipeline

The key concept of message handlers is chaining them together. This example uses several handlers, so the order matters. Add them to the pipeline in a specific sequence to resolve ZIP resources and log execution time during HTML to PDF rendering.

To log conversion time:

1. Create an instance of the Configuration class.
2. Add ZipFileSchemaMessageHandler to resolve resources from the ZIP archive.
3. Insert StartRequestDurationLoggingMessageHandler at the beginning of the pipeline.
4. Add StopRequestDurationLoggingMessageHandler at the end of the pipeline.
5. Initialize an HTMLDocument with the configured pipeline.
6. Create a PDF device and render HTML to PDF.

// Implement custom zip schema with request duration logging using C# message handlers

// Add this line before you try to use the 'IBM437' encoding
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

// Prepare path to a source zip file
string documentPath = Path.Combine(DataDir, "test.zip");

// Prepare path for converted file saving
string savePath = Path.Combine(OutputDir, "zip-to-pdf-duration.pdf");

// Create an instance of the Configuration class
using Configuration configuration = new Configuration();
INetworkService service = configuration.GetService<INetworkService>();
MessageHandlerCollection handlers = service.MessageHandlers;

// Custom Schema: ZIP. Add ZipFileSchemaMessageHandler to the end of the pipeline
handlers.Add(new ZipFileSchemaMessageHandler(new Archive(documentPath)));

// Duration Logging. Add the StartRequestDurationLoggingMessageHandler at the first place in the pipeline
handlers.Insert(0, new StartRequestDurationLoggingMessageHandler());

// Add the StopRequestDurationLoggingMessageHandler to the end of the pipeline
handlers.Add(new StopRequestDurationLoggingMessageHandler());

// Initialize an HTML document with specified configuration
using HTMLDocument document = new HTMLDocument("zip-file:///test.html", configuration);

// Create the PDF Device
using PdfDevice device = new PdfDevice(savePath);

// Render ZIP to PDF
document.RenderTo(device);

The Configuration() constructor creates an instance of the Configuration class. After the configuration is created, the GetService<INetworkService>(), MessageHandlers.Add(), and MessageHandlers.Insert() methods are invoked. Insert() places a handler at a specific position in the collection; Add() appends a handler to the end. The figure shows the chain of message handlers for this example:

Note: The HTMLDocument(address, configuration) constructor takes the absolute path to the ZIP archive. Related resources can still use paths relative to the HTML document inside the archive, as shown in the example.

You can download the complete examples and data files from GitHub.

FAQ

Why use two logging handlers?

The start handler records the beginning of request processing, and the stop handler records the end. Their positions in the pipeline define what part of the workflow is measured.

Does this example measure only PDF rendering?

It measures the request execution path handled by the configured message handlers while the HTML document is loaded and rendered to PDF.

Can I combine logging with other custom handlers?

Yes. Message handlers are designed as a pipeline, so logging can be combined with ZIP resource resolution, authentication, request filtering, and timeout handling.

Related Articles

• Convert HTML from ZIP Archive to PDF – resolve packaged HTML resources and render the result to PDF.
• Web Request Execution Time – measure request execution time in a focused example.
• Message Handler Use Cases in C# – compare message handler scenarios.