log::error doesn't work in #[call_from_java()] methods

[iXanadu13]

workspace structure:

.
├──src
│   ├──lib.rs
│   └──main.rs
├──src-java
│   ├──src
│   │   └──main/java/com/github/ixanadu13/test
│   │        ├──util
│   │        │    └──Log.java
│   │        ├──HelloJNA.java
│   │        └──Main.java
│   │
│   ├──target
│   │   └──...
│   └──pom.xml
└──Cargo.toml

lib.rs:

use j4rs::prelude::*;
use j4rs_derive::*;
use j4rs::{ClasspathEntry, Instance, Jvm, JvmBuilder};

thread_local! {
    pub static JVM: Jvm = {
        let entry = ClasspathEntry::new("src-java/target/classes");
        let jvm = JvmBuilder::new()
            .classpath_entry(entry)
            .build()
            .expect("Failed to construct JVM");

        jvm
    };
}

#[call_from_java("com.github.ixanadu13.test.util.Log.error0")]
fn log_error(msg: Instance) {
    log::error!("it won't work.");
    JVM.with(|jvm| {
        let msg: String = jvm.to_rust(msg).unwrap();
        // also no output
        log::error!("[Java] Error: {}", msg);
        println!("println works");
    });
}

main.rs:

use j4rs::InvocationArg;

fn main() {
    env_logger::init();
    log::error!("it works");
    test_lib::JVM.with(|jvm| {
        jvm.invoke_static(
            "com.github.ixanadu13.test.HelloJNA", 
            "callNoArg", 
            InvocationArg::empty()
        ).unwrap();
    });
}

Log.java:

package com.github.ixanadu13.test.util;

import org.astonbitecode.j4rs.api.Instance;
import org.astonbitecode.j4rs.api.java2rust.Java2RustUtils;

public class Log {
    static {
        System.loadLibrary("test_lib");
    }

    public static void error(String msg){
        error0(Java2RustUtils.createInstance(msg));
    }
    private static native void error0(Instance<String> msg);
}

HelloJNA.java:

package com.github.ixanadu13.test;

import com.github.ixanadu13.test.util.Log;

public class HelloJNA {
    public static String hello(String name) {
        return "Hello, " + name;
    }
    public static void callNoArg() {
        Log.error("Test");
    }
}

Cargo.toml:

[package]
name = "jna_test"
version = "0.1.0"
edition = "2021"

[lib]
name = "test_lib"
crate-type = ["staticlib", "cdylib", "rlib"]

[dependencies]
j4rs = "0.21.0"
j4rs_derive = "0.1"
log = "0.4"
env_logger = "0.11.5"

output:

    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
     Running `target\debug\jna_test.exe`
[2025-02-03T11:39:40Z ERROR jna_test] it works
println works

I upload it on Github: https://github.com/iXanadu13/jna_test

[astonbitecode]

call_from_java implies that Java world loads your native library in order to be able to call its methods. However, this "loading" does not mean that the JVM actually accesses the memory layout that has been initialized along with the native executable (the executable that started with main.rs).

This means, when Java calls your native function with call_from_java, any initialization you did in main (like env_logger::init();) is not valid.

What you try to achieve (Rust calls Java to call back Rust), is a callback in j4rs. So, if you want to get back to your Rust application a value that was generated in Java, you have two choices:

1. Use async to generate any values in a CompletableFuture in Java and get the value in Rust as described here.
2. Use a callback channel as described here.

The first allows using j4rs in async contexts. The second may even allow receiving multiple values from Java, whenever they are ready, via the channel.

EDIT: Fixed the link for the description of the callbacks

[iXanadu13]

Thanks for your reply firstly.
Actually, what I want to achieve is using a java lib in my rust application. The logic in java side is complex and Log.error() is invoked here.
In other word, callback design is not suitable for me. I just want to unify the management of log output in Rust.

[astonbitecode]

I made mistake in the link above regarding the callback channel description, you may have a look (corrected now).

So, if you cannot change the Java implementation, maybe you could try initializing the logging in the function that is marked with #[call_from_java("com.github.ixanadu13.test.util.Log.error0")].

I am not sure if it will work though...

---

In case you can change the Java implementation, you could consider changing the implementation of the Log class, so that it extends the NativeCallbackToRustChannelSupport, something like:

package com.github.ixanadu13.test.util;

import org.astonbitecode.j4rs.api.invocation.NativeCallbackToRustChannelSupport;

public class Log extends NativeCallbackToRustChannelSupport {

    private static Log instance;

    // Instantiate is called from the Rust side, 
    // to initialize the NativeCallbackToRustChannelSupport
    public Log() {
        Log.setInstance(this);
    }

    private static synchronized void setInstance(Log log) {
        if (instance == null) {
            instance = log;
        }
    }

    // This remains the same, no api changes
    public static void error(String msg){
        instance.doLog(msg);
    }

    // Logging is sent to the callback channel
    private void doLog(String msg){
        doCallback(msg);
    }
    
}

In Rust, you could have a listening thread receiving the messages from the channel and do the logging. Something like:

   thread::spawn(move || {
        test_lib::JVM.with(|jvm| {
            // Instantiate the Log class
            let i = jvm
                .create_instance("com.github.ixanadu13.test.util.Log", InvocationArg::empty())
                .unwrap();
            // Get the callback channel from the above instance
            let r = jvm
                .init_callback_channel(&i)
                .unwrap();

            // Log the messages received from the channel
            loop {
                let ret = r.rx().recv().unwrap();
                let s: String = jvm.to_rust(ret).unwrap();
                log::error!("{s}");
            }
        });
    });

Of course, if you are ok with the fact that the log messages will be actually synchronized (because they are handed over by a channel).

[iXanadu13]

After I use call_once, log works in call_from_java functions.

static LOG_INIT: Once = Once::new();

#[call_from_java("com.github.ixanadu13.test.util.Log.error0")]
fn log_error(msg: Instance) {
    LOG_INIT.call_once(|| env_logger::init());
    JVM.with(|jvm| {
        let msg: String = jvm.to_rust(msg).unwrap();
        log::error!("[Java] Error: {}", msg);
    });
}

Thank you so much for your patient guidance and detailed explanation!

[iXanadu13]

After quite some time, I’ve come to realize that the callback is indeed what I needed. The issue arose because I only recently fully understood that the function in call_from_java does not share the same memory space as my Rust main program (as you mentioned, Java loads its own instance of the dynamic library).

After initializing OnceLock in the main program, I found that when I tried to access it inside the function in call_from_java, it always returned None. In the end, I used callback and some tricks to establish a persistent channel between the Java and Rust layers. 😄
Thank you again for your help and guidance.