Alright, let’s break down how to get those modern, scalable Micronaut applications running like a charm with some observability magic. Observability is that secret sauce, giving you a clear view of your application’s behavior and performance. Here’s how to get down with some advanced logging and tracing using Micronaut.

Kickstarting Advanced Logging

Logging is like having a personal diary for your application. It records what’s happening, so you can figure out where things went wrong or how to make them better. Micronaut plays nicely with various logging frameworks, but Logback is a favorite.

Setting Up Logback

First things first, you’ll need to configure the logging levels and choose your loggers. Let’s take a peak at what your logback.xml might look like:

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n</pattern>
        </layout>
    </appender>

    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>

    <logger name="io.micronaut" level="DEBUG"/>
    <logger name="io.netty.handler.logging" level="TRACE"/>
</configuration>

This setup throws log messages to the console and sets different logging levels for Micronaut and Netty.

Using Micronaut’s Logging Features

Micronaut comes with some cool built-in logging features that you can tweak right in your configuration file, be it application.yml or application.properties.

micronaut:
  server:
    netty:
      logLevel: TRACE

This lines will give you more detailed logs for the Netty HTTP server, which can be pretty handy for sorting out network issues.

Getting into Distributed Tracing

Distributed tracing is like putting a GPS on your requests, giving you a map of how they travel through your microservices. Micronaut supports several systems for this, including OpenTelemetry, Jaeger, and Zipkin.

Using OpenTelemetry with Google Cloud Trace

To get OpenTelemetry up and running with Google Cloud Trace, you’ll need to get your dependencies sorted and then configure everything just right.

1. Add Dependencies: Here’s what you need for Gradle:

   implementation("io.micronaut.tracing:micronaut-tracing-opentelemetry")
   implementation("io.opentelemetry:opentelemetry-sdk-trace")
   implementation("io.opentelemetry:opentelemetry-exporter-gcp-trace")
   

2. Create the Application: Fire up the Micronaut CLI and use it to build your app with these features:

   mn create-app example.micronaut.micronautguide \
     --features=yaml,tracing-opentelemetry-gcp,http-client,yaml,tracing-opentelemetry-http \
     --build=gradle \
     --lang=java \
     --test=junit
   

3. Configure Tracing: Pop these lines into your application.yml file:

   tracing:
     opentelemetry:
       enabled: true
     exporter:
       gcp:
         enabled: true
   

4. Set Up Google Cloud Project: Just make sure you’ve got a Google Cloud Platform project set up, and that the Cloud SDK is ready to go. A quick setup with the gcloud tool will sort things out.

Using Jaeger for Distributed Tracing

Jaeger’s another great choice for tracing. Let’s dive into setting it up:

1. Add Dependencies: For Gradle, include this:

   implementation("io.micronaut.tracing:micronaut-tracing-jaeger")
   

2. Enable Jaeger Tracing: Add this config to your application.yml:

   tracing:
     jaeger:
       enabled: true
   

3. Run Jaeger: Get Jaeger running locally using Docker:

   docker run -d \
     -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
     -p 5775:5775/udp \
     -p 6831:6831/udp \
     -p 6832:6832/udp \
     -p 5778:5778 \
     -p 16686:16686 \
     -p 14268:14268 \
     -p 9411:9411 \
     jaegertracing/all-in-one:1.6
   

   You can then head over to http://localhost:16686 to check out the Jaeger UI.

Using Tracing Annotations

Micronaut offers some useful annotations to help manage spans, which are basically units of work within your application. These lie in the io.micronaut.tracing.annotation package.

Creating New Spans

Want to see what’s happening within a method? Use the @NewSpan annotation:

import io.micronaut.tracing.annotation.NewSpan;

public class MyService {
    @NewSpan
    public void doSomething() {
        // Code to be traced
    }
}

Continuing Existing Spans

To build on an existing span, the @ContinueSpan annotation comes in handy:

import io.micronaut.tracing.annotation.ContinueSpan;

public class MyService {
    @ContinueSpan
    public void doSomethingElse() {
        // Code to be traced
    }
}

Adding Span Tags

Include method arguments as tags within a span using @SpanTag:

import io.micronaut.tracing.annotation.NewSpan;
import io.micronaut.tracing.annotation.SpanTag;

public class MyService {
    @NewSpan
    public void doSomething(@SpanTag("username") String username) {
        // Code to be traced
    }
}

Instrumentation and Propagation

Micronaut’s got you covered with various instrumentations to keep the span context hopping across threads and microservices. These live in the io.micronaut.tracing.instrument package, making sure client and server filters propagate those essential headers via HTTP.

Wrapping Up

Getting advanced logging and tracing configured in Micronaut isn’t just crucial – it’s downright empowering. With Logback on logging duties and OpenTelemetry or Jaeger handling tracing, you’ll have a crystal-clear view into your app’s performance and behavior. Plus, those nifty tracing annotations and instruments make life a whole lot easier when managing and debugging your microservices. So roll up those sleeves, and let’s make those Micronaut apps run smoother than ever!