2025-04 on Funky Si's Test

New in .NET Aspire 9.2: diagrams

funkysi1701@gmail.com (funkysi1701) — Mon, 21 Apr 2025 20:00:00 +0000

.NET Aspire 9.2 is here, bringing exciting new features to simplify infrastructure visualization. Whether you’re managing microservices or exploring Docker-based architectures, this release makes it easier than ever to create detailed infrastructure diagrams with minimal effort. Let’s dive into the highlights and see how you can use these tools to streamline your workflow.

For details of what .NET Aspire is, check out my post from last year. For the official announcement see What’s new in .NET Aspire 9.2

My favourite feature from this release is the ability to quickly and easily spin up infrastructure diagrams like this:

An example infrastructure diagram created using .NET Aspire 9.2.

I also created one last week for my blog about Grafana :

So what code is needed to create one of these diagrams?

Open Visual Studio and create a new project of type “.NET Aspire App Host”
Edit the Program.cs and add docker containers for anything you want to display on the diagram
The syntax for this is is shown in my Grafana example:

var builder = DistributedApplication.CreateBuilder(args);

// Add a .NET application container
var dotnet = builder.AddContainer("dotnet-application", "anyimage")
 .WithHttpEndpoint(port: 80, targetPort: 80); // Expose HTTP port 80

// Add a Loki container for log aggregation
var loki = builder.AddContainer("loki", "grafana/loki", "3.4.3")
 .WithHttpEndpoint(port: 3100, targetPort: 3100); // Expose HTTP port 3100

// Add an Alloy container for telemetry processing
var alloy = builder.AddContainer("alloy", "grafana/alloy", "v1.8.1")
 .WithHttpEndpoint(port: 12345, targetPort: 12345, name: "UI") // Expose UI
 .WithHttpEndpoint(port: 4317, targetPort: 4317, name: "gRPC") // Expose gRPC
 .WithHttpEndpoint(port: 4318, targetPort: 4318, "http"); // Expose HTTP

// Add a Grafana container for visualization
var grafana = builder.AddContainer("grafana", "grafana/grafana", "11.6.0")
 .WithHttpEndpoint(port: 3000, targetPort: 3000); // Expose HTTP port 3000

// Define relationships between containers
dotnet.WithReferenceRelationship(alloy); // Logs flow from .NET app to Alloy

alloy.WithReferenceRelationship(loki); // Logs flow from Alloy to Loki

loki.WithReferenceRelationship(grafana); // Logs flow from Loki to Grafana

builder.Build().Run();

The parameters for AddContainer() are a name that gets displayed on the diagram, the docker image name, and the tag. The tag is optional and it will use latest if omitted. For my Grafana example, the first docker container I added is for any dotnet application. I can use any docker image for this, as all I want is a container labelled “dotnet-application”. The .WithHttpEndpoint is for public ports to be displayed so you can see how communication is flowing between containers.

.WithReferenceRelationship() is how you define what calls what. So dotnet.WithReferenceRelationship(alloy) adds an arrow pointing from my dotnet application to alloy, suggesting that open telemetry logs flow from my application to alloy. You can also add calls in both directions by adding alloy.WithReferenceRelationship(dotnet) this will change the arrow to point in both directions.

At my work we use a microservice architecture so I thought it might be fun to try and map out what calls what:

A simplified view of a microservices architecture at work (service names anonymized).

I made a start mapping a few of our services, but this doesn’t cover everything and I have replaced the names of the services so no commerical secrets can be identified. I was surprised at how complex the system is.

Real-World Applications

The ability to generate infrastructure diagrams is invaluable for:

Microservices Architecture: Visualize how services interact and identify bottlenecks.
Debugging: Quickly understand communication flows to troubleshoot issues.
Documentation: Create up-to-date diagrams for team collaboration and onboarding.

Conclusion

.NET Aspire 9.2 makes it easier than ever to create detailed infrastructure diagrams, saving time and improving collaboration. Whether you’re managing microservices or exploring Docker-based architectures, these tools can help you visualize and optimize your systems. Give it a try and see how it can enhance your workflow!

Have you tried .NET Aspire 9.2? What features are you most excited about? Share your thoughts and experiences in the comments below!

OpenTelemetry logs via Grafana Loki

funkysi1701@gmail.com (funkysi1701) — Mon, 14 Apr 2025 20:00:00 +0000

Logs are a critical part of monitoring and debugging modern applications. By integrating OpenTelemetry logs with Grafana using Loki and Alloy, you can centralize your log data, making it easier to analyze and monitor your .NET applications. In this blog, I’ll walk you through the setup process and share how these tools work together to streamline log aggregation and visualization.

I have blogged about Grafana before but until now I haven’t added logs to Grafana let’s have a look at how that works.

My dotnet application makes use of OpenTelemetry. I have been sending this telemetry to an Aspire Dashboard running in Docker. This allows me to view logs, metrics and traces.

Grafana has several tools that can help with logs.

Loki: A log aggregation system designed to store and query logs from applications and infrastructure.
Alloy: An OpenTelemetry collector that processes and forwards telemetry data.
OpenTelemetry: A set of APIs, libraries, and tools for collecting and exporting telemetry data like logs, metrics, and traces.

I am using Alloy to collect OpenTelemetry from my application and send it to Loki, The logs in Loki can then be read by Grafana.

Setting Up Loki and Alloy with Docker Compose

To start off let’s add Alloy and Loki to my docker compose file.

Docker Compose Configuration

The docker-compose.yml file defines the services for Loki and Alloy. Here’s what each section does:

Loki: Runs the Loki container on port 3100 and uses a local configuration file.
Alloy: Runs the Alloy container, exposing ports for receiving telemetry data and processing logs.

# Docker Compose configuration for Loki and Alloy
 command: -config.file=/etc/loki/local-config.yaml # Specifies the configuration file for Loki

 alloy:
 image: grafana/alloy:v1.8.1
 container_name: monitoring_alloy
 ports:
 - 12345:12345 # HTTP server for Alloy
 - 4317:4317 # gRPC endpoint for OpenTelemetry
 - 4319:4318 # HTTP endpoint for OpenTelemetry
 volumes:
 - ./config.alloy:/etc/alloy/config.alloy # Mount Alloy configuration
 command: run --server.http.listen-addr=0.0.0.0:12345 --storage.path=/var/lib/alloy/data /etc/alloy/config.alloy
 depends_on:
 - loki

Here is the config file for Alloy.

otelcol.receiver.otlp "default" {
http {}
grpc {}
output {
logs = [otelcol.processor.batch.default.input]
}
}
otelcol.processor.batch "default" {
output {
logs = [
otelcol.exporter.otlphttp.loki.input,
]
}
}
otelcol.exporter.otlphttp "loki" {
client {
endpoint = "http://loki:3100/otlp"
}
}

How the Components Work Together

Application Logs: The .NET application generates logs and sends them to Alloy on port 4317.
Alloy Processing: Alloy processes the logs and forwards them to Loki on port 3100.
Loki Storage: Loki stores the logs, making them available for querying.
Grafana Visualization: Grafana connects to Loki as a data source, allowing you to visualize and analyze the logs.

Handling Aspire Dashboard Logs

By default, sending logs to Alloy and Loki means Aspire Dashboard will no longer receive them. To resolve this, you can configure the AddOpenTelemetryExporters method in your .NET application to send logs to multiple destinations.

if (useOtlpExporter)
{
 // The following lines enable the OTLP exporter (requires the OpenTelemetry.Exporter.OpenTelemetryProtocol package)
 builder.Services.AddOpenTelemetry()
 .WithLogging(logging => logging.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }))
 .WithLogging(logging => logging.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["GrafanaExporter"]);
 }))
 .WithMetrics(metrics => metrics.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }))
 .WithTracing(tracing => tracing.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }));
}

If I update the AddOpenTelemetryExporters method in my Extensions.cs file in my .Net Aspire ServiceDefaults project, I can get my logs (or traces/metrics) to be sent to as many different places as I want. In my case I am sending to Allot and Aspire Dashboard.

Conclusion

Integrating OpenTelemetry logs with Grafana using Loki and Alloy provides a powerful solution for centralized log aggregation and monitoring. This setup simplifies debugging and enhances visibility into your application’s behaviour. If you haven’t tried it yet, give it a go and let me know your thoughts in the comments!

Exploring ChatGPT image generation

funkysi1701@gmail.com (funkysi1701) — Mon, 07 Apr 2025 20:00:00 +0000

Fun with AI

AI tools like ChatGPT are evolving rapidly, and their creative capabilities are nothing short of amazing. Recently, I decided to test its image generation features with a fun and quirky prompt. The results? A personalized action figure concept that blew my mind! Let me walk you through the process and share the results.

I used the following prompt:

Draw an action figure toy of the person in this photo.
The action figure should be full-figure and displayed in its original blister pack packaging.
On top of the box is the name of the toy "Software Developer" across a single line of text.
In the blister pack packaging, next to the figure, show the toy's accessories,
including a Microsoft laptop,
cup of coffee,
the Visual Studio app,
GitHub app,
and the Azure app.
There should be a label on the corner of the box that says "Limited Edition".
This figure should look like a premium toy and everything should be inside the plastic!

and I supplied the following image:	and this is the result:

Pretty cool, right? Well I can’t take the credit for the prompt, It comes from Amy Ru on LinkedIn.

Have you tried ChatGPT’s image generation features? What creative prompts have you used? Share your experiences in the comments below!