Publish Application Logs to the Oracle Cloud Infrastructure Logging Service

This guide describes how to create an application that publishes logs to the Oracle Cloud Infrastructure Logging service. Typically, application logs are written to stdout and to files, but the Micronaut Logging module supports multiple logging frameworks such as Logback, and logging to various other appenders, to email, a database, or other destinations.

The Oracle Cloud Infrastructure Logging service is a highly scalable and fully managed single pane of glass for all the logs in your tenancy. Logging provides access to logs from Oracle Cloud Infrastructure resources. These logs include critical diagnostic information that describes how resources are performing and being accessed.

Prerequisites #

JDK 17 or higher. See Setting up Your Desktop.
An Oracle Cloud Infrastructure account. See Setting up Your Cloud Accounts.
The Oracle Cloud Infrastructure CLI installed with local access configured.
An Oracle Cloud Infrastructure compartment with appropriate permissions to manage Logs granted to your Oracle Cloud Infrastructure user account.
The GCN CLI. See Setting up Your Desktop. (Optional.)

Follow the steps below to create the application from scratch. However, you can also download the completed example in Java:

Gradle
Maven

Gradle Oracle Cloud Infrastructure Logging Example Download completed example

Maven Oracle Cloud Infrastructure Logging Example Download completed example

A note regarding your development environment

Consider using Visual Studio Code that provides native support for developing applications with the Graal Cloud Native extension.

If you use IntelliJ IDEA, enable annotation processing.

Windows platform: The GCN guides are compatible with Gradle only. Maven support is coming soon.

1. Create the Application #

Create an application using the GCN Launcher.

Open the GCN Launcher in advanced mode.
Create a new project using the following selections.
- Project Type: Application (Default)
- Project Name: oci-logging-demo
- Base Package: com.example (Default)
- Clouds: OCI
- Language: Java (Default)
- Build Tool: Gradle (Groovy) or Maven
- Test Framework: JUnit (Default)
- Java Version: 17 (Default)
- Micronaut Version: (Default)
- Cloud Services: Logging
- Features: GraalVM Native Image (Default)
- Sample Code: Yes (Default)
Click Generate Project, then click Download Zip. The GCN Launcher creates an application with the default package com.example in a directory named oci-logging-demo. The application ZIP file will be downloaded in your default downloads directory. Unzip it, open in your code editor, and proceed to the next steps.

Alternatively, use the GCN CLI as follows:

Gradle
Maven

gcn create-app com.example.oci-logging-demo \
    --clouds=oci \
    --services=logging \
    --features=graalvm \
    --build=gradle \
    --jdk=17 \
    --lang=java

gcn create-app com.example.oci-logging-demo \
    --clouds=oci \
    --services=logging \
    --features=graalvm \
    --build=maven \
    --jdk=17 \
    --lang=java

The GCN Launcher creates a multimodule project with two subprojects: oci for Oracle Cloud Infrastructure, and lib. You develop the application logic in the oci subproject. If your application is to be deployed to multiple cloud providers, use the lib subproject to create classes that can be shared between the providers. This enables you to separate the code that is different between cloud providers, while keeping most of the implementation in the common lib subproject.

The Micronaut Logging service that you selected at the project generation step bundles Logback, Jackson Databind, Oracle Cloud Infrastructure Logging, and other necessary dependencies. The Logback appender publishes logs to Oracle Cloud Infrastructure.

1.1. Controller Class #

The example code includes a controller in a file named oci/src/main/java/com/example/LogController.java, which enables you to send POST requests to publish a message to a log:

package com.example;

import io.micronaut.http.annotation.Body;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Post;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Controller
class LogController {

    private static final Logger LOG = LoggerFactory.getLogger(LogController.class);

    @Post("/log")
    void log(@Body String message) {
        LOG.info(message);
    }
}

2. Get Started with the Oracle Cloud Infrastructure Logging Service #

To use the Oracle Cloud Infrastructure Logging service, first create a Log Group and then a Custom Log.

Follow the steps described in Creating a Log Group to create a Log Group. Use “GCN_Log_Group” as its name and description.
Follow the steps described in Creating a Log to create a Custom Log in the Log group you created in step 1.. Use “GCN_Custom_Log” as the name of the Log. When prompted to create agent configuration, select Add configuration later then click Create agent config.
Click the name of the new custom log to view its details, and from the Log Information tab, copy its OCID (click Copy).

3. Configure Appender #

The GCN Launcher provided a file named oci/src/main/resources/logback.xml containing the configuration for an appender that publishes log statements to the Oracle Cloud Logging service. Update the file to include the OCI of the custom Log you copied earlier. Replace this line:

<logId><!-- TODO set the value of the Oracle Cloud Infrastructure log OCID here --></logId>

with this (the OCID of the Log):

<logId>ocid1.log.oc1.iad.ama...</logId>

Note: You can un-comment the STDOUT appender as the ‘emergency’ appender. See the file for details.

Having configured the appender, you can proceed to run the application, publishing the logs.

4. Run the Application, Publish and View Logs #

Run the application using the following command (it will start the application on port 8080):
- Gradle
- Maven
```
./gradlew :oci:run
```
```
./mvnw install -pl lib -am
./mvnw mn:run -pl oci
```

Send some curl requests to test logging:

curl -id '{"message":"your message here"}' \
   -H "Content-Type: application/json" \
   -X POST http://localhost:8080/log

In the Oracle Cloud console, open the navigation menu, go to Observability & Management. Under Logging, click Logs, then click the name of the new custom log to view the logs published by your application.

5. Generate a Native Executable Using GraalVM #

GCN supports compiling a Java application ahead-of-time into a native executable using GraalVM Native Image. You can use the Gradle plugin for GraalVM Native Image building/Maven plugin for GraalVM Native Image building. Packaged as a native executable, it significantly reduces application startup time and memory footprint.

To generate a native executable, run the following command:

Gradle
Maven

./gradlew :oci:nativeCompile

The native executable is created in the oci/build/native/nativeCompile/ directory and can be run with the following command:

oci/build/native/nativeCompile/oci

./mvnw install -pl lib -am
./mvnw package -pl oci -Dpackaging=native-image

The native executable is created in the oci/target/ directory and can be run with the following command:

oci/target/oci

6. Run and Test the Native Executable #

Run the native executable, and then perform the same request as in step 4.

Summary #

This guide demonstrated how to use GCN to create an application that publishes logs to the Oracle Cloud Infrastructure Logging service. Then, using the Oracle Cloud Infrastructure Logging service, you viewed the logs produced by the application. Finally, you saw how to build a native executable for this application with GraalVM Native Image, and ran it to test publishing logs to Oracle Cloud Infrastructure Logging.