Logging: Associate logs with object being created

I have Spring Boot project with a MainService that uses several helper methods and other "microservices" to create a FinalObject, that's eventually persisted using Hibernate/JPA. The methods and services may log several messages, and I want these to be associated with the object that was being created when the logged event occurred.

The problem is that the helper methods and microservices don't have access to the finalObject instance, so even though everything is logged, only caught exceptions get saved as a finalObject attribute - not warning messages or other logs:

class FinalObject {
    private int value;
    private int price;
    private List<String> logs;
    ...
}
class MainService {
    @Autowired ValueService valueService;  // + other services

    void createFinalObject() {  // Main method
        FinalObject o1 = new FinalObject();
        try {
            o1.setValue(valueService.getValue("some argument"));
        }
        catch (Exception e) {
            log.error(e.toString());  // Logging using Log4j2
            o1.addLog(e.toString());  // If there's an exception, I can easily log it to a o1 attribute.
        }
        o1.setPrice(calculatePrice(o1.getValue()));
        ...
    }
    int calculatePrice(int value) {  // Helper method
        if (value > getMarketPrice())
            log.info("This is very valuable!");  // I need a way to associate this with o1!
        ...
        return price;
    }
}
// ValueService.java
int getValue(String arg) {
    if (arg.matches("\\d$"))
        log.warn("arg ends with a number");  // Must also be saved to o1!
    ...
    return value;
}

Solution 1: Passing o1 around everywhere:

int calculatePrice(int value, FinalObject o1) {
    if (value > getMarketPrice()) {
        o1.addLog("This is very valuable!");  // Now I have access to o1 here
        log.info("This is very valuable!");
    }
    ...

Solution 2: Pass o1's logs attribute around as a modifiable list:

o1.setPrice(calculatePrice(o1.getValue(), o1.getLogs()));
...
int calculatePrice(int value, List<String> finalObjectLogs) {
    if (value > getMarketPrice()) {
        finalObjectLogs.add("This is very valuable!");  // Directly modify o1's logs attribute
        log.info("This is very valuable!");
    }
    ...

Solution 3: Add a log4j2 database appender

A more elegant solution may be do add a database appender to log4j2. A challenge with this is how I can relate these logs to o1. The FinalObject id only gets generated at the very end of createFinalObject(), when it is saved to the database, so I don't have an id when the log statements are executed.

Question:

How can I do this more elegantly than the ways I mentioned above?

Or:

If solution 3 seems like a good approach, how do I implement it?

You can use spring sleuth and logging filters to log the endpoints.
Check the Spring Sleuth Docs;

https://docs.spring.io/spring-cloud-sleuth/docs/2.2.4.RELEASE/reference/html/

You can create a filter do log every endpoint, or log one of them.

And with this loggers you can log the types that you want.

I am curious. In your example the method calculate price doesn't seem to relate to any object so why would you want to include information about a particular object in it?

On the other hand, if you want to correlate it with other operations being performed in a single Request I would suggest you look at the RequestContext that Log4j-Audit describes. You don't have to use Log4j Audit to implement something like this. It simply leverages the Log4j ThreadContext and defines specific keys that are used. You then initialized the values in the ThreadContext and the beginning of the request and clear it at the end of the Request. You can add items to the ThreadContext as needed. Log4j can then be configured to include specific keys in every log event.

I should note that Spring Cloud Sleuth is doing something that I have been doing for years. To propagate the Request information from one service to the next they simply need to be converted to and from HTTP headers when calling a service and when the service starts. That is why the Log4j-Audit example RequestContext shows annotations to classify the attributes as ClientServer, Local, or Chained. It then provides the components needed to accomplish this.