feat: logScriptLoading - this may be unnecessary really, added for alpha testing largely

Author: NathanWalker

test-app/runtime/src/main/cpp/ModuleInternalCallbacks.cpp

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 #include <algorithm>
+#include <atomic>
 
 using namespace v8;
 using namespace std;
@@ -16,6 +17,39 @@ using namespace tns;
 // External global module registry declared in ModuleInternal.cpp
 extern std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
 
+// Forward declaration used by logging helper
+std::string GetApplicationPath();
+
+// Cached toggle for verbose script loading logs sourced from Java AppConfig via JNI
+static bool ShouldLogScriptLoading() {
+    static std::atomic<int> cached{-1}; // -1 unknown, 0 false, 1 true
+    int v = cached.load(std::memory_order_acquire);
+    if (v != -1) {
+        return v == 1;
+    }
+
+    static std::once_flag initFlag;
+    std::call_once(initFlag, []() {
+        bool enabled = false;
+        try {
+            JEnv env;
+            jclass runtimeClass = env.FindClass("com/tns/Runtime");
+            if (runtimeClass != nullptr) {
+                jmethodID mid = env.GetStaticMethodID(runtimeClass, "getLogScriptLoadingEnabled", "()Z");
+                if (mid != nullptr) {
+                    jboolean res = env.CallStaticBooleanMethod(runtimeClass, mid);
+                    enabled = (res == JNI_TRUE);
+                }
+            }
+        } catch (...) {
+            // ignore and keep default false
+        }
+        cached.store(enabled ? 1 : 0, std::memory_order_release);
+    });
+
+    return cached.load(std::memory_order_acquire) == 1;
+}
+
 // Import meta callback to support import.meta.url and import.meta.dirname
 void InitializeImportMetaObject(Local<Context> context, Local<Module> module, Local<Object> meta) {
     Isolate* isolate = context->GetIsolate();
@@ -41,9 +75,11 @@ void InitializeImportMetaObject(Local<Context> context, Local<Module> module, Lo
         modulePath = "";  // Will use fallback path
     }
 
-    DEBUG_WRITE("InitializeImportMetaObject: Module lookup: found path = %s", 
-                modulePath.empty() ? "(empty)" : modulePath.c_str());
-    DEBUG_WRITE("InitializeImportMetaObject: Registry size: %zu", g_moduleRegistry.size());
+    if (ShouldLogScriptLoading()) {
+        DEBUG_WRITE("InitializeImportMetaObject: Module lookup: found path = %s",
+                    modulePath.empty() ? "(empty)" : modulePath.c_str());
+        DEBUG_WRITE("InitializeImportMetaObject: Registry size: %zu", g_moduleRegistry.size());
+    }
 
     // Convert file path to file:// URL
     std::string moduleUrl;
@@ -55,7 +91,9 @@ void InitializeImportMetaObject(Local<Context> context, Local<Module> module, Lo
         moduleUrl = "file:///android_asset/app/";
     }
 
-    DEBUG_WRITE("InitializeImportMetaObject: Final URL: %s", moduleUrl.c_str());
+    if (ShouldLogScriptLoading()) {
+        DEBUG_WRITE("InitializeImportMetaObject: Final URL: %s", moduleUrl.c_str());
+    }
 
     Local<String> url = ArgConverter::ConvertToV8String(isolate, moduleUrl);
 
@@ -128,8 +166,9 @@ v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
     }
 
     // Debug logging
-    DEBUG_WRITE("ResolveModuleCallback: Resolving '%s'", spec.c_str());
-    __android_log_print(ANDROID_LOG_DEBUG, "TNS.ResolveCallback", "Resolving module: '%s'", spec.c_str());
+    if (ShouldLogScriptLoading()) {
+        DEBUG_WRITE("ResolveModuleCallback: Resolving '%s'", spec.c_str());
+    }
 
     // 2) Find which filepath the referrer was compiled under
     std::string referrerPath;
@@ -161,8 +200,10 @@ v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
         std::string cleanSpec = spec.substr(0, 2) == "./" ? spec.substr(2) : spec;
         std::string candidate = baseDir + cleanSpec;
         candidateBases.push_back(candidate);
-        DEBUG_WRITE("ResolveModuleCallback: Relative import: '%s' + '%s' -> '%s'", 
-                   baseDir.c_str(), cleanSpec.c_str(), candidate.c_str());
+    if (ShouldLogScriptLoading()) {
+            DEBUG_WRITE("ResolveModuleCallback: Relative import: '%s' + '%s' -> '%s'",
+                       baseDir.c_str(), cleanSpec.c_str(), candidate.c_str());
+        }
     } else if (spec.size() > 7 && spec.substr(0, 7) == "file://") {
         // Absolute file URL
         std::string tail = spec.substr(7);  // strip file://
@@ -178,19 +219,27 @@ v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
         if (tail.rfind(appVirtualRoot, 0) == 0) {
             // Drop the leading "/app/" and prepend real appPath
             candidate = appPath + "/" + tail.substr(appVirtualRoot.size());
-            DEBUG_WRITE("ResolveModuleCallback: file:// to appPath mapping: '%s' -> '%s'", tail.c_str(), candidate.c_str());
+            if (ShouldLogScriptLoading()) {
+                DEBUG_WRITE("ResolveModuleCallback: file:// to appPath mapping: '%s' -> '%s'", tail.c_str(), candidate.c_str());
+            }
         } else if (tail.rfind(androidAssetAppRoot, 0) == 0) {
             // Replace "/android_asset/app/" with the real appPath
             candidate = appPath + "/" + tail.substr(androidAssetAppRoot.size());
-            DEBUG_WRITE("ResolveModuleCallback: file:// android_asset mapping: '%s' -> '%s'", tail.c_str(), candidate.c_str());
+            if (ShouldLogScriptLoading()) {
+                DEBUG_WRITE("ResolveModuleCallback: file:// android_asset mapping: '%s' -> '%s'", tail.c_str(), candidate.c_str());
+            }
         } else if (tail.rfind(appPath, 0) == 0) {
             // Already an absolute on-disk path to the app folder
             candidate = tail;
-            DEBUG_WRITE("ResolveModuleCallback: file:// absolute path preserved: '%s'", candidate.c_str());
+            if (ShouldLogScriptLoading()) {
+                DEBUG_WRITE("ResolveModuleCallback: file:// absolute path preserved: '%s'", candidate.c_str());
+            }
         } else {
             // Fallback: treat as absolute on-disk path
             candidate = tail;
-            DEBUG_WRITE("ResolveModuleCallback: file:// generic absolute: '%s'", candidate.c_str());
+            if (ShouldLogScriptLoading()) {
+                DEBUG_WRITE("ResolveModuleCallback: file:// generic absolute: '%s'", candidate.c_str());
+            }
         }
 
         candidateBases.push_back(candidate);
@@ -423,7 +472,9 @@ v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
 
     // 7) Handle JSON modules
     if (absPath.size() >= 5 && absPath.compare(absPath.size() - 5, 5, ".json") == 0) {
-        DEBUG_WRITE("ResolveModuleCallback: Handling JSON module '%s'", absPath.c_str());
+    if (ShouldLogScriptLoading()) {
+            DEBUG_WRITE("ResolveModuleCallback: Handling JSON module '%s'", absPath.c_str());
+        }
 
         // Read JSON file content
         std::string jsonText = Runtime::GetRuntime(isolate)->ReadFileText(absPath);
@@ -475,12 +526,16 @@ v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
     // 8) Check if we've already compiled this module
     auto it = g_moduleRegistry.find(absPath);
     if (it != g_moduleRegistry.end()) {
-        DEBUG_WRITE("ResolveModuleCallback: Found cached module '%s'", absPath.c_str());
+    if (ShouldLogScriptLoading()) {
+            DEBUG_WRITE("ResolveModuleCallback: Found cached module '%s'", absPath.c_str());
+        }
         return v8::MaybeLocal<v8::Module>(it->second.Get(isolate));
     }
 
     // 9) Compile and register the new module
-    DEBUG_WRITE("ResolveModuleCallback: Compiling new module '%s'", absPath.c_str());
+    if (ShouldLogScriptLoading()) {
+        DEBUG_WRITE("ResolveModuleCallback: Compiling new module '%s'", absPath.c_str());
+    }
     try {
         // Use our existing LoadESModule function to compile the module
         tns::ModuleInternal::LoadESModule(isolate, absPath);
@@ -513,8 +568,9 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
     v8::String::Utf8Value specUtf8(isolate, specifier);
     std::string spec = *specUtf8 ? *specUtf8 : "";
 
-    DEBUG_WRITE("ImportModuleDynamicallyCallback: Dynamic import for '%s'", spec.c_str());
-    __android_log_print(ANDROID_LOG_DEBUG, "TNS.ImportCallback", "Dynamic import: '%s'", spec.c_str());
+    if (ShouldLogScriptLoading()) {
+        DEBUG_WRITE("ImportModuleDynamicallyCallback: Dynamic import for '%s'", spec.c_str());
+    }
 
     v8::EscapableHandleScope scope(isolate);
 
@@ -537,7 +593,9 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
         v8::Local<v8::Module> module;
         if (!maybeModule.ToLocal(&module)) {
             // Resolution failed; reject to avoid leaving a pending Promise (white screen)
-            DEBUG_WRITE("ImportModuleDynamicallyCallback: Resolution failed for '%s'", spec.c_str());
+            if (ShouldLogScriptLoading()) {
+                DEBUG_WRITE("ImportModuleDynamicallyCallback: Resolution failed for '%s'", spec.c_str());
+            }
             v8::Local<v8::Value> ex = v8::Exception::Error(
                 ArgConverter::ConvertToV8String(isolate, std::string("Failed to resolve module: ") + spec));
             resolver->Reject(context, ex).Check();
@@ -547,7 +605,9 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
         // If not yet instantiated/evaluated, do it now
         if (module->GetStatus() == v8::Module::kUninstantiated) {
             if (!module->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
-                DEBUG_WRITE("ImportModuleDynamicallyCallback: Instantiate failed for '%s'", spec.c_str());
+                if (ShouldLogScriptLoading()) {
+                    DEBUG_WRITE("ImportModuleDynamicallyCallback: Instantiate failed for '%s'", spec.c_str());
+                }
                 resolver
                     ->Reject(context,
                              v8::Exception::Error(ArgConverter::ConvertToV8String(isolate, "Failed to instantiate module")))
@@ -558,7 +618,9 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
 
         if (module->GetStatus() != v8::Module::kEvaluated) {
             if (module->Evaluate(context).IsEmpty()) {
-                DEBUG_WRITE("ImportModuleDynamicallyCallback: Evaluation failed for '%s'", spec.c_str());
+                if (ShouldLogScriptLoading()) {
+                    DEBUG_WRITE("ImportModuleDynamicallyCallback: Evaluation failed for '%s'", spec.c_str());
+                }
                 v8::Local<v8::Value> ex =
                     v8::Exception::Error(ArgConverter::ConvertToV8String(isolate, "Evaluation failed"));
                 resolver->Reject(context, ex).Check();
@@ -567,10 +629,14 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
         }
 
         resolver->Resolve(context, module->GetModuleNamespace()).Check();
-        DEBUG_WRITE("ImportModuleDynamicallyCallback: Successfully resolved '%s'", spec.c_str());
+    if (ShouldLogScriptLoading()) {
+            DEBUG_WRITE("ImportModuleDynamicallyCallback: Successfully resolved '%s'", spec.c_str());
+        }
     } catch (NativeScriptException& ex) {
         ex.ReThrowToV8();
-        DEBUG_WRITE("ImportModuleDynamicallyCallback: Native exception for '%s'", spec.c_str());
+    if (ShouldLogScriptLoading()) {
+            DEBUG_WRITE("ImportModuleDynamicallyCallback: Native exception for '%s'", spec.c_str());
+        }
         resolver
             ->Reject(context, v8::Exception::Error(
                                   ArgConverter::ConvertToV8String(isolate, "Native error during dynamic import")))

test-app/runtime/src/main/java/com/tns/AppConfig.java

@@ -20,7 +20,8 @@ protected enum KnownKeys {
         ForceLog("forceLog", false),
         DiscardUncaughtJsExceptions("discardUncaughtJsExceptions", false),
         EnableLineBreakpoins("enableLineBreakpoints", false),
-        EnableMultithreadedJavascript("enableMultithreadedJavascript", false);
+        EnableMultithreadedJavascript("enableMultithreadedJavascript", false),
+        LogScriptLoading("logScriptLoading", false);
 
         private final String name;
         private final Object defaultValue;
@@ -57,6 +58,9 @@ public AppConfig(File appDir) {
                     String profiling = rootObject.getString(KnownKeys.Profiling.getName());
                     values[KnownKeys.Profiling.ordinal()] = profiling;
                 }
+                if (rootObject.has(KnownKeys.LogScriptLoading.getName())) {
+                    values[KnownKeys.LogScriptLoading.ordinal()] = rootObject.getBoolean(KnownKeys.LogScriptLoading.getName());
+                }
                 if (rootObject.has(KnownKeys.DiscardUncaughtJsExceptions.getName())) {
                     values[KnownKeys.DiscardUncaughtJsExceptions.ordinal()] = rootObject.getBoolean(KnownKeys.DiscardUncaughtJsExceptions.getName());
                 }
@@ -171,4 +175,9 @@ public boolean getDiscardUncaughtJsExceptions() {
     public boolean getEnableMultithreadedJavascript() {
         return (boolean)values[KnownKeys.EnableMultithreadedJavascript.ordinal()];
     }
+
+    public boolean getLogScriptLoading() {
+    Object v = values[KnownKeys.LogScriptLoading.ordinal()];
+    return (v instanceof Boolean) ? ((Boolean)v).booleanValue() : false;
+    }
 }

test-app/runtime/src/main/java/com/tns/Runtime.java

@@ -222,6 +222,8 @@ public Runtime(StaticConfiguration config, DynamicConfiguration dynamicConfigura
                 runtimeCache.put(this.runtimeId, this);
 
                 gcListener = GcListener.getInstance(config.appConfig.getGcThrottleTime(), config.appConfig.getMemoryCheckInterval(), config.appConfig.getFreeMemoryRatio());
+                // capture static configuration to allow native lookups when currentRuntime is unavailable
+                Runtime.staticConfiguration = config;
             } finally {
                 frame.close();
             }
@@ -254,6 +256,18 @@ public static boolean isDebuggable() {
         }
     }
 
+    // Expose logScriptLoading flag for native code without re-reading package.json
+    public static boolean getLogScriptLoadingEnabled() {
+        Runtime runtime = com.tns.Runtime.getCurrentRuntime();
+        if (runtime != null && runtime.config != null && runtime.config.appConfig != null) {
+            return runtime.config.appConfig.getLogScriptLoading();
+        }
+        if (staticConfiguration != null && staticConfiguration.appConfig != null) {
+            return staticConfiguration.appConfig.getLogScriptLoading();
+        }
+        return false;
+    }
+
     private static Runtime getObjectRuntime(Object object) {
         Runtime runtime = null;