Staging

CHANGELOG.md

@@ -1,8 +1,20 @@
-## 24.1.3
+## 24.1.5
+* Fixed a bug where a non-JSON server response would cause a permanent networking deadlock, preventing all subsequent requests from being sent.
+* Fixed a bug where a NullPointerException in SDKCore.recover() would permanently block SDK initialization when a crash file from a previous session existed on disk.
+
+## 24.1.4
+* ! Minor breaking change ! User properties will now be automatically saved under the following conditions:
+  * When an event is recorded
+  * During an internal timer tick
+  * Upon flushing the event queue
+  * When a session call made
+* Cleaned up unused gradle dependencies from root build.gradle.
 
+## 24.1.3
 * Extended minimum JDK support to 8.
 
 ## 24.1.2
+
 * !! Major Breaking Change !! Minimum JDK support is 19 for this minor.
 
 * Migrated from Sonatype OSSRH.
@@ -214,3 +226,4 @@
 
 * initial SDK release
 * MavenCentral rerelease 
+

app-java/build.gradle

@@ -16,4 +16,4 @@ dependencies {
   //implementation "ly.count.sdk:java:${CLY_VERSION}"
 }
 
-mainClassName = 'ly.count.java.demo.Sample'
+mainClassName = 'ly.count.java.demo.ReproduceIssue264'

app-java/src/main/java/ly/count/java/demo/ReproduceIssue263.java

@@ -0,0 +1,118 @@
+package ly.count.java.demo;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import ly.count.sdk.java.Config;
+import ly.count.sdk.java.Countly;
+import org.json.JSONObject;
+
+/**
+ * Reproducer for GitHub issue #263:
+ * "NullPointerException in SDKCore.recover() permanently blocks SDK initialization
+ * when a crash file exists"
+ *
+ * This simulates the scenario where:
+ * 1. A previous app run crashed and left a [CLY]_crash_* file on disk
+ * 2. The app restarts and calls Countly.init()
+ * 3. SDKCore.recover() finds the crash file and tries to process it
+ *
+ * WITHOUT the fix: NPE at networking.check(config) because networking is null
+ * WITH the fix: SDK initializes normally, crash is queued as a request
+ */
+public class ReproduceIssue263 {
+
+    public static void main(String[] args) {
+        String[] sdkStorageRootPath = { System.getProperty("user.home"), "__COUNTLY", "java_issue_263" };
+        File sdkStorageRootDirectory = new File(String.join(File.separator, sdkStorageRootPath));
+
+        if (!(sdkStorageRootDirectory.exists() && sdkStorageRootDirectory.isDirectory())) {
+            if (!sdkStorageRootDirectory.mkdirs()) {
+                System.out.println("[FAIL] Directory creation failed");
+                return;
+            }
+        }
+
+        // Step 1: Plant a fake crash file as if a previous run crashed
+        long crashTimestamp = System.currentTimeMillis() - 2000;
+        File crashFile = new File(sdkStorageRootDirectory, "[CLY]_crash_" + crashTimestamp);
+
+        JSONObject crashData = new JSONObject();
+        crashData.put("_error", "java.lang.RuntimeException: simulated crash from previous session\n"
+            + "\tat com.example.App.doSomething(App.java:42)\n"
+            + "\tat com.example.App.main(App.java:10)");
+        crashData.put("_nonfatal", false);
+        crashData.put("_os", "Java");
+        crashData.put("_os_version", System.getProperty("java.version"));
+        crashData.put("_device", "ReproducerDevice");
+        crashData.put("_resolution", "1920x1080");
+
+        try (BufferedWriter writer = Files.newBufferedWriter(crashFile.toPath())) {
+            writer.write(crashData.toString());
+        } catch (IOException e) {
+            System.out.println("[FAIL] Could not write crash file: " + e.getMessage());
+            return;
+        }
+
+        System.out.println("[INFO] Planted crash file: " + crashFile.getAbsolutePath());
+        System.out.println("[INFO] Crash file exists: " + crashFile.exists());
+        System.out.println();
+
+        // Step 2: Initialize SDK — this is where the NPE would occur
+        System.out.println("[TEST] Initializing SDK with crash file present...");
+        System.out.println("[TEST] If issue #263 is NOT fixed, you will see a NullPointerException below.");
+        System.out.println();
+
+        try {
+            Config config = new Config("https://test.server.ly", "TEST_APP_KEY", sdkStorageRootDirectory)
+                .setLoggingLevel(Config.LoggingLevel.DEBUG)
+                .enableFeatures(Config.Feature.CrashReporting, Config.Feature.Events, Config.Feature.Sessions);
+
+            Countly.instance().init(config);
+
+            System.out.println();
+            System.out.println("[PASS] SDK initialized successfully!");
+            System.out.println("[INFO] Crash file still exists: " + crashFile.exists());
+
+            if (!crashFile.exists()) {
+                System.out.println("[PASS] Crash file was processed and removed during recovery.");
+            } else {
+                System.out.println("[WARN] Crash file was NOT removed — recovery may have partially failed.");
+            }
+
+            // Check for request files (crash should be converted to a request)
+            File[] requestFiles = sdkStorageRootDirectory.listFiles(
+                (dir, name) -> name.startsWith("[CLY]_request_"));
+            if (requestFiles != null && requestFiles.length > 0) {
+                System.out.println("[PASS] Found " + requestFiles.length + " request file(s) — crash was queued for sending.");
+            }
+
+            // Clean shutdown
+            Countly.instance().halt();
+            System.out.println("[INFO] SDK stopped cleanly.");
+
+        } catch (NullPointerException e) {
+            System.out.println();
+            System.out.println("[FAIL] *** NullPointerException — Issue #263 is NOT fixed! ***");
+            System.out.println("[FAIL] " + e.getMessage());
+            e.printStackTrace();
+        } catch (Exception e) {
+            System.out.println();
+            System.out.println("[FAIL] Unexpected exception: " + e.getClass().getSimpleName() + ": " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            // Cleanup: remove test files
+            System.out.println();
+            System.out.println("[INFO] Cleaning up test directory...");
+            File[] files = sdkStorageRootDirectory.listFiles();
+            if (files != null) {
+                for (File f : files) {
+                    f.delete();
+                }
+            }
+            sdkStorageRootDirectory.delete();
+            System.out.println("[INFO] Done.");
+        }
+    }
+}

app-java/src/main/java/ly/count/java/demo/ReproduceIssue264.java

@@ -0,0 +1,179 @@
+package ly.count.java.demo;
+
+import com.sun.net.httpserver.HttpServer;
+import java.io.File;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.net.InetSocketAddress;
+import java.util.concurrent.atomic.AtomicInteger;
+import ly.count.sdk.java.Config;
+import ly.count.sdk.java.Countly;
+
+/**
+ * Reproduces GitHub Issue #264:
+ * "Non-JSON Server Response Causes Permanent Networking Deadlock"
+ *
+ * This app starts a local HTTP server that returns HTML (simulating a 502 error page),
+ * initializes the Countly SDK against it, records events, and checks whether the SDK
+ * gets permanently stuck.
+ *
+ * Run with: ./gradlew app-java:run
+ * (after setting mainClassName = 'ly.count.java.demo.ReproduceIssue264' in app-java/build.gradle)
+ */
+public class ReproduceIssue264 {
+
+    public static void main(String[] args) throws Exception {
+        AtomicInteger requestCount = new AtomicInteger(0);
+        AtomicInteger successCount = new AtomicInteger(0);
+
+        // Start a local HTTP server that returns HTML for the first 3 requests,
+        // then valid JSON for subsequent requests (simulating server recovery)
+        HttpServer server = HttpServer.create(new InetSocketAddress(0), 0);
+        int port = server.getAddress().getPort();
+
+        server.createContext("/", exchange -> {
+            int count = requestCount.incrementAndGet();
+            String body;
+            int code;
+
+            if (count <= 3) {
+                code = 502;
+                body = "<html><body><h1>502 Bad Gateway</h1><p>The server is temporarily unavailable.</p></body></html>";
+                System.out.println("[Mock Server] Request #" + count + " -> returning HTML 502 (simulating outage)");
+            } else {
+                code = 200;
+                body = "{\"result\":\"Success\"}";
+                successCount.incrementAndGet();
+                System.out.println("[Mock Server] Request #" + count + " -> returning JSON 200 (server recovered)");
+            }
+
+            exchange.sendResponseHeaders(code, body.length());
+            OutputStream os = exchange.getResponseBody();
+            os.write(body.getBytes());
+            os.close();
+        });
+
+        server.start();
+        System.out.println("=== Issue #264 Reproduction ===");
+        System.out.println("[Mock Server] Started on port " + port);
+        System.out.println();
+
+        // Setup SDK storage directory
+        String[] sdkStorageRootPath = { System.getProperty("user.home"), "__COUNTLY", "java_issue264" };
+        File sdkStorageRootDirectory = new File(String.join(File.separator, sdkStorageRootPath));
+        if (!(sdkStorageRootDirectory.exists() && sdkStorageRootDirectory.isDirectory())) {
+            sdkStorageRootDirectory.mkdirs();
+        }
+
+        // Initialize SDK pointing to our mock server
+        Config config = new Config("http://localhost:" + port, "TEST_APP_KEY", sdkStorageRootDirectory)
+            .setLoggingLevel(Config.LoggingLevel.WARN)
+            .setDeviceIdStrategy(Config.DeviceIdStrategy.UUID)
+            .enableFeatures(Config.Feature.Events, Config.Feature.Sessions)
+            .setEventQueueSizeToSend(1);
+
+        Countly.instance().init(config);
+        System.out.println("[SDK] Initialized against mock server");
+
+        // Start session (triggers first request -> will get HTML 502)
+        Countly.session().begin();
+        System.out.println("[SDK] Session started");
+
+        // Record an event (triggers another request -> will get HTML 502)
+        Countly.instance().events().recordEvent("test_event_during_outage");
+        System.out.println("[SDK] Event recorded");
+
+        // Wait for requests to be attempted
+        System.out.println();
+        System.out.println("[Test] Waiting 3 seconds for initial requests...");
+        Thread.sleep(3000);
+
+        // Check if SDK is deadlocked via reflection (SDKCore.instance.networking is protected)
+        boolean isSending = isNetworkingSending();
+
+        System.out.println();
+        System.out.println("============================================================");
+        if (isSending) {
+            System.out.println("  BUG REPRODUCED: isSending() = true (DEADLOCKED!)");
+            System.out.println("  The SDK is permanently stuck. No further requests");
+            System.out.println("  will ever be sent, even when the server recovers.");
+        } else {
+            System.out.println("  FIX CONFIRMED: isSending() = false (recovered)");
+            System.out.println("  The SDK handled the non-JSON response gracefully.");
+        }
+        System.out.println("============================================================");
+        System.out.println();
+
+        // Try to trigger recovery by calling check
+        System.out.println("[Test] Triggering networking check cycles (server now returns JSON)...");
+        triggerNetworkingChecks(5);
+
+        int totalRequests = requestCount.get();
+        int successes = successCount.get();
+
+        System.out.println();
+        System.out.println("============================================================");
+        System.out.println("  Total requests received by server: " + totalRequests);
+        System.out.println("  Successful (JSON 200) responses:   " + successes);
+        if (successes > 0) {
+            System.out.println("  SDK successfully retried after server recovered!");
+        } else if (!isNetworkingSending()) {
+            System.out.println("  SDK recovered from error. Requests will retry on");
+            System.out.println("  the next timer tick (no deadlock).");
+        } else {
+            System.out.println("  SDK is STILL deadlocked. Bug confirmed.");
+        }
+        System.out.println("============================================================");
+
+        // Cleanup
+        Countly.instance().stop();
+        server.stop(0);
+        System.out.println();
+        System.out.println("[Done] Cleanup complete.");
+    }
+
+    /**
+     * Access SDKCore.instance.networking.isSending() via reflection
+     * since these fields are protected/package-private.
+     */
+    private static boolean isNetworkingSending() throws Exception {
+        Class<?> sdkCoreClass = Class.forName("ly.count.sdk.java.internal.SDKCore");
+        Field instanceField = sdkCoreClass.getDeclaredField("instance");
+        instanceField.setAccessible(true);
+        Object sdkCore = instanceField.get(null);
+
+        Field networkingField = sdkCoreClass.getDeclaredField("networking");
+        networkingField.setAccessible(true);
+        Object networking = networkingField.get(sdkCore);
+
+        return (boolean) networking.getClass().getMethod("isSending").invoke(networking);
+    }
+
+    /**
+     * Trigger SDKCore.instance.networking.check(config) via reflection.
+     */
+    private static void triggerNetworkingChecks(int count) throws Exception {
+        Class<?> sdkCoreClass = Class.forName("ly.count.sdk.java.internal.SDKCore");
+        Field instanceField = sdkCoreClass.getDeclaredField("instance");
+        instanceField.setAccessible(true);
+        Object sdkCore = instanceField.get(null);
+
+        Field networkingField = sdkCoreClass.getDeclaredField("networking");
+        networkingField.setAccessible(true);
+        Object networking = networkingField.get(sdkCore);
+
+        Field configField = sdkCoreClass.getDeclaredField("config");
+        configField.setAccessible(true);
+        Object internalConfig = configField.get(sdkCore);
+
+        java.lang.reflect.Method checkMethod = networking.getClass().getMethod("check",
+            Class.forName("ly.count.sdk.java.internal.InternalConfig"));
+
+        for (int i = 0; i < count; i++) {
+            if (!isNetworkingSending()) {
+                checkMethod.invoke(networking, internalConfig);
+            }
+            Thread.sleep(1000);
+        }
+    }
+}

build.gradle

@@ -1,37 +1,21 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    repositories {
-        google()
-        mavenCentral()
-        jcenter()
-        maven {
-            url "https://maven.google.com"
-        }
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:8.1.4'
-        classpath 'com.github.dcendents:android-maven-plugin:1.2'
-        classpath 'com.google.gms:google-services:4.4.2'
-
-        // NOTE: Do not place your application dependencies here; they belong
-        // in the individual module build.gradle files
-    }
+  repositories {
+    google()
+    mavenCentral()
+  }
 }
 
 allprojects {
-    ext.CLY_VERSION = "24.1.3"
-    ext.POWERMOCK_VERSION = "1.7.4"
+  ext.CLY_VERSION = "24.1.5"
+  ext.POWERMOCK_VERSION = "1.7.4"
 
-    tasks.withType(Javadoc) {
-        options.addStringOption('Xdoclint:none', '-quiet')
-    }
-    repositories {
-        google()
-        jcenter()
-        //mavenLocal()
-        maven {
-            url "https://maven.google.com" // Google's Maven repository
-        }
-    }
+  tasks.withType(Javadoc) {
+    options.addStringOption('Xdoclint:none', '-quiet')
+  }
+  repositories {
+    google()
+    mavenCentral()
+  }
 }

gradle.properties

@@ -18,7 +18,7 @@
 # org.gradle.parallel=true
 
 # RELEASE FIELD SECTION
-VERSION_NAME=24.1.3
+VERSION_NAME=24.1.5
 GROUP=ly.count.sdk
 
 POM_URL=https://github.com/Countly/countly-sdk-java