Microservices

A Service Boundary Homework Problem

I guess it was inevitable, but quite often I see homework problems on r/microservices seemingly assigned in some intro CS class. Peculiarities of that aside, they can be quite fun to work through as thought experiments. One recent one came up: Hi, I am working on a school app.

Microservices

Activity Enrichment in ASP.NET Core 6.0

Waaaaay back in the ASP.NET Core 3.1 days, I wrote about increasing the cardinality of traces using Tags and Baggage. You could write code in your controllers, filters, or application code to be able to add custom information to traces to help find these traces more effectively: [HttpGet]

Microservices

A Lap Around ActivitySource and ActivityListener in .NET 5

Part of the new DiagnosticSource API are new ways of "listening" in to activities with the addition of the ActivitySource and ActivityListener APIs. These are intended to replace the DiagnosticSource and DiagnosticListener APIs. However, the latter two types aren't deprecated, and aren't being removed from the existing usages. However, ActivitySource/

Microservices

Increasing Trace Cardinality with Activity Tags and Baggage

One of the first "oh no" moments for folks new to distributed tracing is the needle in the haystack problem. Someone reports an error, you go look for traces in your tool (Azure Monitor or whatever), and because there are thousands of traces, you can't easily figure out which is

Microservices

Building End-to-End Diagnostics: ActivitySource and OpenTelemetry 1.0

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 It's a few months, and quite a lot has changed in the tracing landscape in .NET. As OpenTelemetry marches towards 1.

Microservices

Building End-to-End Diagnostics: User-Defined Context with Correlation Context

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code With a brief detour to push out some NuGet packages, I wanted to pick up with a common issue

Microservices

Building End-to-End Diagnostics: Visualization with Exporters

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code In the last post, we looked at surfacing our diagnostics events from the Activity and DiagnosticSource APIs on through

Microservices

Building End-to-End Diagnostics: Activity and Span Correlation

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code In the last post, we looked at hooking up our diagnostics events (and Activities) to OpenTelemetry, where our main

Microservices

Building End-to-End Diagnostics: OpenTelemetry Integration

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code In the last post, we looked at providing diagnostic event hooks into our code at specific points so that

Microservices

Building End-to-End Diagnostics and Tracing: Diagnostic Events

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code In the last post, we looked at the W3C Trace Context standard, and how we can extend NServiceBus to

Microservices

Building End-to-End Diagnostics and Tracing: Trace Context

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code In the last post, I walked through the overall problem we run into with diagnosing issues in distributed systems

Microservices

Building End-to-End Diagnostics and Tracing: An Intro

Posts in this series: * An Intro * Trace Context * Diagnostic Events * OpenTelemetry Integration * Activity and Span Correlation * Visualization with Exporters * User-Defined Context with Correlation Context * ActivitySource and OpenTelemetry 1.0 Source Code As microservices introduced (forced) highly complex distributed systems into organizations, the tools required to operate these architectures needed to

Messaging

Immutability in Message Types

In just about every custom I've worked with, eventually the topic of immutability in messages comes up. Messages are immutable in concept, that is, we shouldn't change them (except in the case of document messages). Since messages are generally immutable in concept, why not make them immutable in our applications

Microservices

Message Naming Conventions

One of the first design decisions teams starting with messaging are presented with are - what the heck do we name these things? When building out request/response types for typical API/web applications, I name the responses usually after the resource they represent, or the route, or controller/action.

Microservices

Composite UIs for Microservices: Vertical Slice APIs

This is a recent follow-up pattern to my series on Composite UIs in Microservices, which explores various strategies for composing at the edges. Other posts in this series: * A primer * Composition options * Client composition * Server composition * Data composition * Vertical Slice APIs When looking at a client-side composition, the next logical

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Conclusion

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion We started out with a common, but nearly always overlooked problem: how do we reliably coordinate activities between different transactional resources? The question we need to ask first is

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Relational Resources

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series So far in this series we've mainly concerned ourselves with a single resource that can't support distributed (or multi-entity) transactions. While that is becoming

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Sagas

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series So far in this series, we've looked at the ins and outs of moving beyond distributed transactions using persisted messages as a means of

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Dispatcher Failure Recovery

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series In the last post, we looked at how we can recover from exceptions from inside our code handling messages. We perform some action in

Architecture

Life Beyond Distributed Transactions: An Apostate's Implementation - Failures and Retries

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series In the last post, we looked at an example of dispatching document messages to other documents using a central dispatcher. Our example worked well

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Dispatching Example

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series In the last post, we looked at refactoring our documents to use messaging to communicate changes. We're still missing something, however - the dispatcher:

Microservices

Life Beyond Distributed Transactions: An Apostate's Implementation - Document Example

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series In the last post, I walked through the "happy path" scenario of coordinated communication/activities between multiple resources that otherwise can't participate in a

Distributed Systems

Life Beyond Distributed Transactions: An Apostate's Implementation - Document Coordination

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series Quick note - I've updated this post to use the more accurate term "Document" than the less-accurate, DDD-specific term "Aggregate". In the images, it

Distributed Systems

Life Beyond Distributed Transactions: An Apostate's Implementation - A Primer

Posts in this series: * A Primer * Document Coordination * Document Example * Dispatching Example * Failures and Retries * Failure Recovery * Sagas * Relational Resources * Conclusion Sample code from this series For those working with SQL databases, working with transactions is more or less a given. The most we may need to worry about is:

Microservices

The False Dichotomy of Monoliths and Microservices

When learning about microservices, you're nearly always introduced to the concept of a monolith. If you're not doing microservices, you're building a monolith. If you're not building a monolith, you must go with microservices. If you're building a monolith, perhaps you're doing it well and it's a majestic monolith. From