DEV Community: Volkmar Rigo

How to use the Aspire Dashboard with a legacy WinForms application

Volkmar Rigo — Thu, 14 Aug 2025 20:57:46 +0000

Introduction

If you have a legacy Windows Forms (WinForms) application and want to add modern observability, this post shows how to wire up OpenTelemetry tracing in .NET Framework and stream it to the .NET Aspire Dashboard — using only a lightweight Docker container and a few lines of code.

But why use Aspire Dashboard for legacy apps? Modern observability platforms can feel out of reach for older desktop applications. The .NET Aspire Dashboard gives you a clean UI to inspect traces locally, and OpenTelemetry provides a vendor-neutral way to capture telemetry from your code.

The main challanges are:

configure OpenTelemetry and the Aspire Dashboard to work with the .Net Framework 4.7.2
manually add traces because auto instrumentation is not available for desktop applications

I've created a proof of concept that shows how to solve both issues. It is available at https://github.com/VolkmarR/OTEL-Traces-Winforms-Aspire

Aspire Dashboard configuration

The repo contains a docker compose file with the necessary configuration for the Aspire Dashboard.

Since the GRPC Protocol is not supported by the .Net Framework 4.7.2, it is very important to add the "4318:18890" port mapping, used by the HttpProtobuf Protocol.

Application configuration

The OpenTelemetry.Exporter.OpenTelemetryProtocol nuget package must be added to the WinForms application.

This function needs to be added to the project and called in the program.cs. Make sure that the setup method is only executed for local development and not for production.

// OTEL_Traces/OpenTelemetry/Tracing.cs
using System;
using System.Diagnostics;
using System.Windows.Forms;
using OpenTelemetry;
using OpenTelemetry.Exporter;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

public static class Tracing
{
    public static ActivitySource TelemetrySource;

    // Initializes OpenTelemetry and sends data to Aspire.
    public static TracerProvider Setup(string sourceName)
    {
        TelemetrySource = new ActivitySource(sourceName);

        return Sdk.CreateTracerProviderBuilder()
            .AddSource(sourceName)
            .AddOtlpExporter(o =>
            {
                o.Protocol = OtlpExportProtocol.HttpProtobuf;
                o.Endpoint = new Uri("http://localhost:4318/v1/traces");
            })
            .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(
                Application.ProductName.Replace(' ', '-'),
                serviceVersion: "1.0",
                autoGenerateServiceInstanceId: false))
            .Build();
    }
}

Instrumentation

Since there is no automatic instrumentation, the spans for the traces must be added manually to the code.

There are different ways to approach this. My recommendation is to find methods in your base classes that perform noteworthy tasks that take a certain amount of time. Executing SQL statements or making HTTP calls are good examples.

Here is the example from the repo, simulating an SQL execution

public void Execute(string sql)
{
    Activity activity = null;
    try
    {
        // Only start a child activity when there is a parent.
        if (Activity.Current != null)
            activity = Tracing.TelemetrySource.StartActivity();

        // add custom information to the span
        activity?.SetTag("custom.sql", sql);

        // ...

    }
    finally
    {
        activity?.Dispose();
    }
}

This way, spans are only created when a root activity was created before.

These root activities can be started in methods that are triggered by the user (button clicks, ...).

Here's the example for that.

private void LoadButton_Click(object sender, EventArgs e)
{
    // ...

    using (var _ = Tracing.TelemetrySource.StartActivity())
    {
        for (var i = 0; i < userCount; i++)
            query.Execute($"Select * from Users where Id = {i}");
    }

    // ...
}

Summary

This article contains the key steps to use OpenTelemetry and the Aspire Dashboard in a legacy Winforms application. The github repo mentioned in the article contains a working prototype to show how this works in practice.

Is generated code harder to maintain?

Volkmar Rigo — Tue, 30 Jan 2024 11:26:48 +0000

Code quality and maintainability

I found an interesting article about code quality and maintainability of AI generated code.

This is the TL;DR:

GitHub Copilot usage has led to an increase in AI-assisted code, which in turn has created a downward pressure on code quality. Code written with AI is often harder to maintain and of lower quality as it’s often verbose or copy-pasted. However, GitHub Copilot has had a positive effect on developer productivity and satisfaction.

My conclusion

So it looks like, that you have to be careful when using Copilot to not trade higher initial productivity right now with higher maintenance cost in the future...

What's your opinion?

Photo by Mimi Thian on Unsplash

DuckDB: an embedded DB for data wrangling

Volkmar Rigo — Sun, 01 Nov 2020 19:14:58 +0000

Last week, ThoughtWorks released it's latest edition of the Technology Radar. One of the new entries to the platform section was DuckDB. This new DB sounded interesting, so I decided to check it out.

What is DuckDB

ThoughtWorks describes it as

DuckDB is an embedded, columnar database for data science and analytical workloads. Analysts spend significant time cleaning and visualizing data locally before scaling it to servers. Although databases have been around for decades, most of them are designed for client-server use cases and therefore not suitable for local interactive queries. To work around this limitation analysts usually end up using in-memory data-processing tools such as Pandas or data.table. Although these tools are effective, they do limit the scope of analysis to the volume of data that can fit in memory. We feel DuckDB neatly fills this gap in tooling with an embedded columnar engine that is optimized for analytics on local, larger-than-memory data sets.

Similar to SQLite, it's a relational database, that supports SQL, without the necessity of installing and managing an SQL server. Additionally, it is optimized to be super-fast, even with large datasets, that don't fit in memory.

Test drive

Test data creation

To test a database, first you need some data. So I created a python script and used Faker to create the following CSV files:

persons.csv (10.000 rows)
id,name,street,city,email
1,Ronald Montgomery,300 Smith Heights Apt. 722,Shannonview,arellanotyler@ramirez.com

books.csv (10.000 rows)
1,978-0-541-64306-5,Exclusive systemic knowledge user,1,27.31

orderItems  (1.000.000 rows)
id,person_id,book_id,quantity,date
1,7001,47034,3,2020-08-16

Installation of DuckDB

In order to use it, you have to install the DuckDB library. This is done using pip install duckdb==0.2.2

The test

For the test, I defined the following task: Create a CSV file, that contains the total amount of the sold books (quantity * price) per person category.

This is the code to solve this task

import duckdb
from time import time
start = time()

# Connect to database. 
# If no filename is specified, the db will be created in memory
conn = duckdb.connect()

# Create tables and load data from CSV files
conn.execute("CREATE TABLE persons as Select * from read_csv_auto ('persons.csv')")
conn.execute("CREATE TABLE books as Select * from  read_csv_auto ('books.csv')")
conn.execute("CREATE TABLE orderItems as Select * from  read_csv_auto ('orderItems.csv')")

# Execute the query to get the result and use copy to export it as CSV file
conn.execute("""copy (SELECT category, round(sum(quantity * price), 2) amount FROM orderItems 
inner Join persons on person_id = persons.id 
inner Join books on book_id = books.id
group by category
order by category) to 'result.csv' (HEADER)""")

# Print execution time
print("Executed in ", time() - start)

The execution time is around 2 seconds on my PC and the result file looks like this:

category,amount
1,13203562.05
2,13120658.42
3,12378199.17
4,12183193.4
5,13450846.14
6,13111841.91
7,12438200.33
8,12750379.26
9,12881481.69
10,12118417.6

Summary

So what do I think about DuckDB after this quick test? I have to say, I really like it. I've worked with SQL for a long time and thanks to DuckDB, I can reuse this skill to wrangle with data. I can work in memory and seamless switch to using a database file, if the data exceeds memory.

What do you think? Ready to give DuckDB a try? BTW: It also plays nice with pandas too.