Tech: Ensuring Netty Performance on Apple Silicon: A Gradle Solution

At Kedos Consulting, we recently navigated a challenge that many developers might face when ensuring their Java applications, particularly those utilizing Netty and Spring Boot Webflux, perform optimally on various platforms, including the increasingly popular Apple Silicon (ARM architecture). This blog post digs into the issue related to Netty's DNS resolver on macOS ARM64 and our solution leveraging Gradle's conditional dependency inclusion.

The Challenge with Netty on Apple Silicon

While developing or running Java applications on Apple Silicon, we encountered a notable issue: Netty failed to load the appropriate DNS resolver optimized for macOS ARM64. This problem manifested as an error, preventing the application from utilizing macOS's native DNS resolver capabilities, which could lead to incorrect DNS resolutions:

i.n.r.d.DnsServerAddressStreamProviders  : Unable to load io.netty.resolver.dns.macos.MacOSDnsServerAddressStreamProvider, fallback to system defaults. This may result in incorrect DNS resolutions on MacOS.

This error was particularly perplexing in applications built with Spring Boot Webflux, as we noticed reactor-netty-http pulling in io.netty:netty-resolver-dns-native-macos with the osx-x86_64 classifier indiscriminately, irrespective of the underlying architecture.

Delving into the Issue

Upon further investigation, inspired by discussions and solutions proposed in netty/netty#11020, it became clear that the crux of the problem was the static inclusion of a platform-specific dependency that did not account for the ARM architecture of Apple Silicon. This oversight led to the application's inability to leverage Netty's native macOS DNS resolver capabilities.

Crafting a Solution with Gradle

Understanding the root cause led us to explore Gradle's capabilities for conditional dependency management. Our goal was to ensure that our build script could dynamically include the appropriate version of io.netty:netty-resolver-dns-native-macos, based on the operating system and architecture. Here's the approach we took:

dependencies {
    // Ensures compatibility across architectures by conditionally including dependencies
    if (System.getProperty("os.name").toLowerCase().contains("mac") &&
        System.getProperty("os.arch").toLowerCase().contains("aarch64")) {
        runtimeOnly 'io.netty:netty-resolver-dns-native-macos:4.1.107.Final:osx-aarch_64'
    }
}

This snippet demonstrates how to conditionally include dependencies in a Gradle build script, specifically targeting macOS ARM64 (make sure the version specified here is compatible with your version of Netty). By doing so, we ensure that applications using Netty on Apple Silicon can leverage the correct DNS resolver, enhancing performance and ensuring accurate DNS resolutions.

The Importance of Conditional Dependencies

The adoption of conditional dependencies in Java and Gradle projects, especially for applications meant to run on a variety of platforms including macOS ARM64, is crucial for several reasons:

• Enhanced Performance: By using platform-optimized libraries, applications can run more efficiently and leverage the hardware's full potential.
• Cross-Platform Compatibility: Conditional dependencies ensure that applications remain functional across different environments without manual intervention or complex configurations.
• Build Optimization: This approach keeps the project lean by avoiding unnecessary or incompatible libraries on platforms where they are not needed, streamlining the development and deployment processes.

Conclusion

The shift towards diverse computing architectures, exemplified by the popularity of Apple Silicon, poses unique challenges for Java developers. By employing Gradle's flexible dependency management system, projects can dynamically adapt to the underlying platform, ensuring optimal performance and compatibility. This solution not only addresses the immediate issue with Netty on macOS ARM64 but also sets a precedent for handling similar platform-specific challenges in the future.

Ensuring that Java applications, particularly those built with frameworks like Spring Boot Webflux and libraries like Netty, perform optimally across all platforms, is essential. Our journey through diagnosing and resolving the Netty DNS resolver issue on Apple Silicon underscores the importance of adaptable build configurations and the power of conditional dependency inclusion.

Using Maven?

If you're facing this issue and using Maven, please look at our followup article here: Ensuring Netty Performance on Apple Silicon: A Maven Solution.