prepare 2.2.0 release (#25)

Author: LaunchDarklyCI

.circleci/config.yml

@@ -28,10 +28,10 @@ jobs:
             cmake -D REDIS_STORE=ON ..
             cmake --build .
       - run:
-          name: Test
+          name: Unit test with memcheck
           command: |
             cd build
-            CTEST_OUTPUT_ON_FAILURE=1 make test
+            ctest -T memcheck
 
   build-test-linux-32bit:
     docker:
@@ -61,11 +61,11 @@ jobs:
           name: Test
           command: |
             cd build
-            CTEST_OUTPUT_ON_FAILURE=1 make test
+            make test
 
   build-test-osx:
     macos:
-      xcode: "9.0"
+      xcode: "9.4.1"
     environment:
       CTEST_OUTPUT_ON_FAILURE: 1
     steps:
@@ -90,7 +90,7 @@ jobs:
           name: Test
           command: |
            cd build
-           CTEST_OUTPUT_ON_FAILURE=1 make test
+           make test
 
   build-test-windows:
     executor:

.ldrelease/config.yml

@@ -8,7 +8,7 @@ circleci:
     env:
       LD_LIBRARY_FILE_PREFIX: linux-gcc-64bit
   mac:
-    xcode: "9.0"
+    xcode: "9.4.1"
     env:
       LD_LIBRARY_FILE_PREFIX: osx-clang-64bit
   windows:

c-sdk-common/include/launchdarkly/logging.h

@@ -21,9 +21,33 @@ typedef enum {
 /** @brief Internal: Used for the non macro portion */
 LD_EXPORT(void) LDi_log(const LDLogLevel level, const char *const format, ...);
 
-/** @brief A provided logger that can be used as a convenient default */
+/**
+ * @brief A provided logger that can be used as a convenient default.
+ * @deprecated This is deprecated in favor of `LDBasicLoggerThreadSafe`.
+ */
 LD_EXPORT(void) LDBasicLogger(const LDLogLevel level, const char *const text);
 
+/**
+ * @brief Setup routine for `LDBasicLoggerThreadSafe`.
+ * Call this before `LDBasicLoggerThreadSafe` is used.
+ */
+LD_EXPORT(void) LDBasicLoggerThreadSafeInitialize(void);
+
+/**
+ * @brief A provided logger that can be used as a convenient default.
+ * Must call `LDBasicLoggerTSInitialize` before use. This should be used instead
+ * of `LDBasicLogger`.
+ */
+LD_EXPORT(void) LDBasicLoggerThreadSafe(
+    const LDLogLevel level, const char *const text);
+
+/**
+ * @brief Shutdown routine for `LDBasicLoggerThreadSafe`
+ * Call this when `LDBasicLoggerThreadSafe` is no longer used, after all
+ * LaunchDarkly resources are destroyed.
+ */
+LD_EXPORT(void) LDBasicLoggerThreadSafeShutdown(void);
+
 /**
  * @brief Set the logger, and the log level to use. This routine should only be
  * used before any other LD routine. After any other routine has been used

c-sdk-common/src/concurrency.c

@@ -147,6 +147,49 @@ LDi_mutex_init_imp(ld_mutex_t *const mutex)
     return status == 0;
 }
 
+static bool
+LDi_mutex_init_nl_imp(ld_mutex_t *const mutex)
+{
+    int status;
+
+    #ifndef _WIN32
+        pthread_mutexattr_t attributes;
+        int kind;
+    #endif
+
+    #ifdef _WIN32
+        InitializeCriticalSection(mutex);
+
+        status = 0;
+    #else
+        if ((status = pthread_mutexattr_init(&attributes)) != 0) {
+            goto done;
+        }
+
+        #ifdef LAUNCHDARKLY_CONCURRENCY_UNSAFE
+            kind = PTHREAD_MUTEX_NORMAL;
+        #else
+            kind = PTHREAD_MUTEX_ERRORCHECK;
+        #endif
+
+        if ((status = pthread_mutexattr_settype(&attributes, kind)) != 0) {
+            goto done;
+        }
+
+        if ((status = pthread_mutex_init(mutex, &attributes)) != 0) {
+            goto done;
+        }
+
+        /* this should never fail */
+        if ((status = pthread_mutexattr_destroy(&attributes)) != 0) {
+            goto done;
+        }
+    #endif
+
+  done:
+    return status == 0;
+}
+
 static bool
 LDi_mutex_destroy_imp(ld_mutex_t *const mutex)
 {
@@ -180,6 +223,22 @@ LDi_mutex_destroy_imp(ld_mutex_t *const mutex)
     return status == 0;
 }
 
+static bool
+LDi_mutex_destroy_nl_imp(ld_mutex_t *const mutex)
+{
+    int status;
+
+    #ifdef _WIN32
+        DeleteCriticalSection(mutex);
+
+        status = 0;
+    #else
+        status = pthread_mutex_destroy(mutex);
+    #endif
+
+    return status == 0;
+}
+
 static bool
 LDi_mutex_lock_imp(ld_mutex_t *const mutex)
 {
@@ -213,6 +272,22 @@ LDi_mutex_lock_imp(ld_mutex_t *const mutex)
     return status == 0;
 }
 
+static bool
+LDi_mutex_lock_nl_imp(ld_mutex_t *const mutex)
+{
+    int status;
+
+    #ifdef _WIN32
+        EnterCriticalSection(mutex);
+
+        status = 0;
+    #else
+        status = pthread_mutex_lock(mutex);
+    #endif
+
+    return status == 0;
+}
+
 static bool
 LDi_mutex_unlock_imp(ld_mutex_t *const mutex)
 {
@@ -246,6 +321,22 @@ LDi_mutex_unlock_imp(ld_mutex_t *const mutex)
     return status == 0;
 }
 
+static bool
+LDi_mutex_unlock_nl_imp(ld_mutex_t *const mutex)
+{
+    int status;
+
+    #ifdef _WIN32
+        LeaveCriticalSection(mutex);
+
+        status = 0;
+    #else
+        status = pthread_mutex_unlock(mutex);
+    #endif
+
+    return status == 0;
+}
+
 static bool
 LDi_rwlock_init_imp(ld_rwlock_t *const lock)
 {
@@ -631,22 +722,27 @@ LDi_cond_init_imp(ld_cond_t *const cond)
     return status == 0;
 }
 
-ld_mutex_unary_t   LDi_mutex_init      = LDi_mutex_init_imp;
-ld_mutex_unary_t   LDi_mutex_destroy   = LDi_mutex_destroy_imp;
-ld_mutex_unary_t   LDi_mutex_lock      = LDi_mutex_lock_imp;
-ld_mutex_unary_t   LDi_mutex_unlock    = LDi_mutex_unlock_imp;
-
-ld_thread_join_t   LDi_thread_join     = LDi_thread_join_imp;
-ld_thread_create_t LDi_thread_create   = LDi_thread_create_imp;
-
-ld_rwlock_unary_t  LDi_rwlock_init     = LDi_rwlock_init_imp;
-ld_rwlock_unary_t  LDi_rwlock_destroy  = LDi_rwlock_destroy_imp;
-ld_rwlock_unary_t  LDi_rwlock_rdlock   = LDi_rwlock_rdlock_imp;
-ld_rwlock_unary_t  LDi_rwlock_wrlock   = LDi_rwlock_wrlock_imp;
-ld_rwlock_unary_t  LDi_rwlock_rdunlock = LDi_rwlock_rdunlock_imp;
-ld_rwlock_unary_t  LDi_rwlock_wrunlock = LDi_rwlock_wrunlock_imp;
-
-ld_cond_unary_t    LDi_cond_init       = LDi_cond_init_imp;
-ld_cond_wait_t     LDi_cond_wait       = LDi_cond_wait_imp;
-ld_cond_unary_t    LDi_cond_signal     = LDi_cond_signal_imp;
-ld_cond_unary_t    LDi_cond_destroy    = LDi_cond_destroy_imp;
+ld_mutex_unary_t   LDi_mutex_init       = LDi_mutex_init_imp;
+ld_mutex_unary_t   LDi_mutex_destroy    = LDi_mutex_destroy_imp;
+ld_mutex_unary_t   LDi_mutex_lock       = LDi_mutex_lock_imp;
+ld_mutex_unary_t   LDi_mutex_unlock     = LDi_mutex_unlock_imp;
+
+ld_mutex_unary_t   LDi_mutex_nl_init    = LDi_mutex_init_nl_imp;
+ld_mutex_unary_t   LDi_mutex_nl_destroy = LDi_mutex_destroy_nl_imp;
+ld_mutex_unary_t   LDi_mutex_nl_lock    = LDi_mutex_lock_nl_imp;
+ld_mutex_unary_t   LDi_mutex_nl_unlock  = LDi_mutex_unlock_nl_imp;
+
+ld_thread_join_t   LDi_thread_join      = LDi_thread_join_imp;
+ld_thread_create_t LDi_thread_create    = LDi_thread_create_imp;
+
+ld_rwlock_unary_t  LDi_rwlock_init      = LDi_rwlock_init_imp;
+ld_rwlock_unary_t  LDi_rwlock_destroy   = LDi_rwlock_destroy_imp;
+ld_rwlock_unary_t  LDi_rwlock_rdlock    = LDi_rwlock_rdlock_imp;
+ld_rwlock_unary_t  LDi_rwlock_wrlock    = LDi_rwlock_wrlock_imp;
+ld_rwlock_unary_t  LDi_rwlock_rdunlock  = LDi_rwlock_rdunlock_imp;
+ld_rwlock_unary_t  LDi_rwlock_wrunlock  = LDi_rwlock_wrunlock_imp;
+
+ld_cond_unary_t    LDi_cond_init        = LDi_cond_init_imp;
+ld_cond_wait_t     LDi_cond_wait        = LDi_cond_wait_imp;
+ld_cond_unary_t    LDi_cond_signal      = LDi_cond_signal_imp;
+ld_cond_unary_t    LDi_cond_destroy     = LDi_cond_destroy_imp;

c-sdk-common/src/concurrency.h

@@ -57,6 +57,11 @@ extern ld_mutex_unary_t   LDi_mutex_destroy;
 extern ld_mutex_unary_t   LDi_mutex_lock;
 extern ld_mutex_unary_t   LDi_mutex_unlock;
 
+extern ld_mutex_unary_t   LDi_mutex_nl_init;
+extern ld_mutex_unary_t   LDi_mutex_nl_destroy;
+extern ld_mutex_unary_t   LDi_mutex_nl_lock;
+extern ld_mutex_unary_t   LDi_mutex_nl_unlock;
+
 extern ld_thread_join_t   LDi_thread_join;
 extern ld_thread_create_t LDi_thread_create;
 

c-sdk-common/src/logging.c

@@ -4,9 +4,11 @@
 #include <launchdarkly/logging.h>
 
 #include "assertion.h"
+#include "concurrency.h"
 
 static LDLogLevel sdkloggerlevel = LD_LOG_INFO;
 static void (*sdklogger)(const LDLogLevel level, const char *const text) = NULL;
+static ld_mutex_t basicLoggerLock;
 
 const char *
 LDLogLevelToString(const LDLogLevel level)
@@ -30,6 +32,30 @@ LDBasicLogger(const LDLogLevel level, const char *const text)
     printf("[%s] %s\n", LDLogLevelToString(level), text);
 }
 
+void
+LDBasicLoggerThreadSafeInitialize(void)
+{
+    LDi_mutex_nl_init(&basicLoggerLock);
+}
+
+void
+LDBasicLoggerThreadSafe(const LDLogLevel level, const char *const text)
+{
+    if (!LDi_mutex_nl_lock(&basicLoggerLock)) {
+        return;
+    }
+
+    printf("[%s] %s\n", LDLogLevelToString(level), text);
+    
+    LDi_mutex_nl_unlock(&basicLoggerLock);
+}
+
+void
+LDBasicLoggerThreadSafeShutdown(void)
+{
+    LDi_mutex_nl_destroy(&basicLoggerLock);
+}
+
 void
 LDConfigureGlobalLogger(const LDLogLevel level,
     void (*logger)(const LDLogLevel level, const char *const text))
@@ -44,9 +70,7 @@ LDi_log(const LDLogLevel level, const char *const format, ...)
     char buffer[4096];
     va_list va;
 
-    LD_ASSERT(format);
-
-    if (!sdklogger || level > sdkloggerlevel) {
+    if (!format || !sdklogger || level > sdkloggerlevel) {
         return;
     }
 

src/store.c

@@ -226,7 +226,11 @@ LDJSONRCNew(struct LDJSON *const json)
     LDi_mutex_init(&result->lock);
 
     result->value = json;
+
+    /* the locking here is only to satisfy helgrind */
+    LDi_mutex_lock(&result->lock);
     result->count = 1;
+    LDi_mutex_unlock(&result->lock);
 
     return result;
 }

tests/test-allflags.c

@@ -60,10 +60,13 @@ testAllFlags()
 int
 main()
 {
-    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLogger);
+    LDBasicLoggerThreadSafeInitialize();
+    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLoggerThreadSafe);
     LDGlobalInit();
 
     testAllFlags();
 
+    LDBasicLoggerThreadSafeShutdown();
+
     return 0;
 }

tests/test-eval.c

@@ -1016,7 +1016,8 @@ testLDi_bucketUserByKey()
 int
 main()
 {
-    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLogger);
+    LDBasicLoggerThreadSafeInitialize();
+    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLoggerThreadSafe);
     LDGlobalInit();
 
     returnsOffVariationIfFlagIsOff();
@@ -1040,5 +1041,7 @@ main()
 
     testLDi_bucketUserByKey();
 
+    LDBasicLoggerThreadSafeShutdown();
+
     return 0;
 }

tests/test-event-processor.c

@@ -484,7 +484,8 @@ testExperimentationRuleNonDetailed()
 int
 main()
 {
-    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLogger);
+    LDBasicLoggerThreadSafeInitialize();
+    LDConfigureGlobalLogger(LD_LOG_TRACE, LDBasicLoggerThreadSafe);
     LDGlobalInit();
 
     testConstructAndFree();
@@ -498,5 +499,7 @@ main()
     testExperimentationFallthroughNonDetailed();
     testExperimentationRuleNonDetailed();
 
+    LDBasicLoggerThreadSafeShutdown();
+
     return 0;
 };