Prevent truncating log tag name

The currently hard-coded limit is 23 characters. This limit originates
from the pre-Android 7.0 32-character limit on system property names,
because Android's `liblog` allows setting the log level at runtime
through `log.tag` system properties [1]. The limit meant that
"log.tag.SOMETAG" must have been shorter than 32 bytes, leaving 23 bytes
for the tag itself.

The system property length limitation was removed in [2], so since 2017
it no longer applies, and some Android components already use longer
tags [3][4].

This change increases the size of the stack-allocated buffer used for
null-terminating the tag to 128 bytes, and adds support for even longer
tags by falling back to heap-allocated CString when the tag is longer
than that. The fallback path will introduce a performance penalty, but
at the same time will allow manual level adjustment via log.tag. system
property regardless of the tag length.

[1] https://cs.android.com/android/platform/superproject/main/+/main:system/logging/logd/README.property;l=50?q=f:readme.property
[2] https://android-review.googlesource.com/c/platform/bionic/+/327226
[3] https://cs.android.com/android/platform/superproject/main/+/main:device/generic/goldfish-opengl/system/codecs/omx/plugin/GoldfishVideoDecoderOMXComponent.cpp;l=20
[4] https://cs.android.com/android/platform/superproject/main/+/main:hardware/interfaces/biometrics/fingerprint/2.2/default/BiometricsFingerprint.cpp;l=16

Author: Marcin Radomski

src/lib.rs

@@ -179,7 +179,7 @@ impl AndroidLogger {
 
 static ANDROID_LOGGER: OnceLock<AndroidLogger> = OnceLock::new();
 
-const LOGGING_TAG_MAX_LEN: usize = 23;
+const LOGGING_TAG_MAX_LEN: usize = 128;
 const LOGGING_MSG_MAX_LEN: usize = 4000;
 
 impl Default for AndroidLogger {
@@ -223,10 +223,20 @@ impl Log for AndroidLogger {
             .map(|s| s.as_bytes())
             .unwrap_or_else(|| module_path.as_bytes());
 
-        // truncate the tag here to fit into LOGGING_TAG_MAX_LEN
-        self.fill_tag_bytes(&mut tag_bytes, tag);
-        // use stack array as C string
-        let tag: &CStr = unsafe { CStr::from_ptr(mem::transmute(tag_bytes.as_ptr())) };
+        // In case we end up allocating, keep the CString alive.
+        let mut _owned_tag = None;
+        let tag: &CStr = if tag.len() < tag_bytes.len() {
+            // use stack array as C string
+            self.fill_tag_bytes(&mut tag_bytes, tag);
+            // SAFETY: fill_tag_bytes always puts a nullbyte in tag_bytes.
+            unsafe { CStr::from_ptr(mem::transmute(tag_bytes.as_ptr())) }
+        } else {
+            // Tag longer than available stack buffer; allocate.
+            // SAFETY: if tag contains nullbytes, the Android logger will just ignore any
+            // characters that follow it.
+            _owned_tag = Some(unsafe { CString::from_vec_unchecked(tag.to_vec()) });
+            _owned_tag.as_ref().unwrap()
+        };
 
         // message must not exceed LOGGING_MSG_MAX_LEN
         // therefore split log message into multiple log calls