+ * By default, the SDK sends logging to Timber. If you want to bypass Timber and use Android
+ * logging directly instead, use this class with {@link LDConfig.Builder#logAdapter(LDLogAdapter)}:
+ *
+ * LDConfig config = new LDConfig.Builder()
+ * .logAdapter(LDAndroidLogging.adapter())
+ * .build();
+ *
+ *
+ * By default, debug-level logging is disabled and all other levels are enabled. To change this,
+ * use {@link LDConfig.Builder#logLevel(LDLogLevel)}.
+ * @since 3.2.0
+ */
+public abstract class LDAndroidLogging {
+ public static LDLogAdapter adapter() {
+ return AdapterImpl.INSTANCE;
+ }
+
+ private static final class AdapterImpl implements LDLogAdapter {
+ static final AdapterImpl INSTANCE = new AdapterImpl();
+
+ @Override
+ public Channel newChannel(String name) {
+ return new ChannelImpl(name);
+ }
+ }
+
+ private static final class ChannelImpl extends ChannelImplBase {
+ public ChannelImpl(String tag) {
+ super(tag);
+ }
+
+ @Override
+ public boolean isEnabled(LDLogLevel level) {
+ return Log.isLoggable(tag, toAndroidLogLevel(level));
+ }
+
+ private static int toAndroidLogLevel(LDLogLevel level) {
+ switch (level) {
+ case DEBUG: return Log.DEBUG;
+ case INFO: return Log.INFO;
+ case WARN: return Log.WARN;
+ case ERROR: return Log.ERROR;
+ default: return Log.VERBOSE;
+ }
+ }
+
+ @Override
+ protected void logInternal(LDLogLevel level, String text) {
+ switch (level) {
+ case DEBUG:
+ Log.d(tag, text);
+ break;
+ case INFO:
+ Log.i(tag, text);
+ break;
+ case WARN:
+ Log.w(tag, text);
+ break;
+ case ERROR:
+ Log.e(tag, text);
+ break;
+ }
+ }
+ }
+
+ abstract static class ChannelImplBase implements LDLogAdapter.Channel {
+ protected final String tag;
+
+ public ChannelImplBase(String tag) {
+ this.tag = tag;
+ }
+
+ protected abstract void logInternal(LDLogLevel level, String text);
+
+ // To avoid unnecessary string computations for debug output, we don't want to
+ // pre-format messages for disabled levels. We'll avoid that by checking if the
+ // level is enabled first.
+
+ @Override
+ public void log(LDLogLevel level, Object message) {
+ if (isEnabled(level)) {
+ logInternal(level, message == null ? null : message.toString());
+ }
+ }
+
+ @Override
+ public void log(LDLogLevel level, String format, Object param) {
+ if (isEnabled(level)) {
+ logInternal(level, SimpleFormat.format(format, param));
+ }
+ }
+
+ @Override
+ public void log(LDLogLevel level, String format, Object param1, Object param2) {
+ if (isEnabled(level)) {
+ logInternal(level, SimpleFormat.format(format, param1, param2));
+ }
+ }
+
+ @Override
+ public void log(LDLogLevel level, String format, Object... params) {
+ if (isEnabled(level)) {
+ logInternal(level, SimpleFormat.format(format, params));
+ }
+ }
+ }
+}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
index 5ee5c5af..0430bb2b 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
@@ -9,6 +9,8 @@
import androidx.annotation.NonNull;
import androidx.annotation.VisibleForTesting;
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.logging.LogValues;
import com.launchdarkly.sdk.EvaluationDetail;
import com.launchdarkly.sdk.EvaluationReason;
import com.launchdarkly.sdk.LDUser;
@@ -36,7 +38,6 @@
import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
-import timber.log.Timber;
/**
* Client for accessing LaunchDarkly's Feature Flag system. This class enforces a singleton pattern.
@@ -53,6 +54,8 @@ public class LDClient implements LDClientInterface, Closeable {
// A lock to ensure calls to `init()` are serialized.
static Object initLock = new Object();
+ private static volatile LDLogger sharedLogger;
+
private final Application application;
private final LDConfig config;
private final DefaultUserManager userManager;
@@ -64,6 +67,7 @@ public class LDClient implements LDClientInterface, Closeable {
private final List> connectionFailureListeners =
Collections.synchronizedList(new ArrayList<>());
private final ExecutorService executor = Executors.newFixedThreadPool(1);
+ private final LDLogger logger;
/**
* Initializes the singleton/primary instance. The result is a {@link Future} which
@@ -98,16 +102,16 @@ public static Future init(@NonNull Application application,
if (user == null) {
return new LDFailedFuture<>(new LaunchDarklyException("Client initialization requires a valid user"));
}
+
+ initSharedLogger(config);
+
// Acquire the `initLock` to ensure that if `init()` is called multiple times, we will only
// initialize the client(s) once.
synchronized (initLock) {
if (instances != null) {
- LDConfig.log().w("LDClient.init() was called more than once! returning primary instance.");
+ getSharedLogger().warn("LDClient.init() was called more than once! returning primary instance.");
return new LDSuccessFuture<>(instances.get(LDConfig.primaryEnvironmentName));
}
- if (BuildConfig.DEBUG) {
- Timber.plant(new Timber.DebugTree());
- }
Foreground.init(application);
@@ -116,14 +120,14 @@ public static Future init(@NonNull Application application,
if (!instanceIdSharedPrefs.contains(INSTANCE_ID_KEY)) {
String uuid = UUID.randomUUID().toString();
- LDConfig.log().i("Did not find existing instance id. Saving a new one");
+ getSharedLogger().info("Did not find existing instance id. Saving a new one");
SharedPreferences.Editor editor = instanceIdSharedPrefs.edit();
editor.putString(INSTANCE_ID_KEY, uuid);
editor.apply();
}
instanceId = instanceIdSharedPrefs.getString(INSTANCE_ID_KEY, instanceId);
- LDConfig.log().i("Using instance id: %s", instanceId);
+ getSharedLogger().info("Using instance id: {}", instanceId);
Migration.migrateWhenNeeded(application, config);
@@ -183,7 +187,7 @@ static LDUser customizeUser(LDUser user) {
String key = user.getKey();
if (key == null || key.equals("")) {
- LDConfig.log().i("User was created with null/empty key. Using device-unique anonymous user key: %s", LDClient.getInstanceId());
+ getSharedLogger().info("User was created with null/empty key. Using device-unique anonymous user key: {}", LDClient.getInstanceId());
builder.key(LDClient.getInstanceId());
builder.anonymous(true);
}
@@ -204,14 +208,16 @@ static LDUser customizeUser(LDUser user) {
* @return The primary LDClient instance
*/
public static LDClient init(Application application, LDConfig config, LDUser user, int startWaitSeconds) {
- LDConfig.log().i("Initializing Client and waiting up to %s for initialization to complete", startWaitSeconds);
+ initSharedLogger(config);
+ getSharedLogger().info("Initializing Client and waiting up to {} for initialization to complete", startWaitSeconds);
Future initFuture = init(application, config, user);
try {
return initFuture.get(startWaitSeconds, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException e) {
- LDConfig.log().e(e, "Exception during Client initialization");
+ getSharedLogger().error("Exception during Client initialization: {}", LogValues.exceptionSummary(e));
+ getSharedLogger().debug(LogValues.exceptionTrace(e));
} catch (TimeoutException e) {
- LDConfig.log().w("Client did not successfully initialize within %s seconds. It could be taking longer than expected to start up", startWaitSeconds);
+ getSharedLogger().warn("Client did not successfully initialize within {} seconds. It could be taking longer than expected to start up", startWaitSeconds);
}
return instances.get(LDConfig.primaryEnvironmentName);
}
@@ -222,7 +228,7 @@ public static LDClient init(Application application, LDConfig config, LDUser use
*/
public static LDClient get() throws LaunchDarklyException {
if (instances == null) {
- LDConfig.log().e("LDClient.get() was called before init()!");
+ getSharedLogger().error("LDClient.get() was called before init()!");
throw new LaunchDarklyException("LDClient.get() was called before init()!");
}
return instances.get(LDConfig.primaryEnvironmentName);
@@ -237,7 +243,7 @@ public static LDClient get() throws LaunchDarklyException {
public static LDClient getForMobileKey(String keyName) throws LaunchDarklyException {
Map instancesNow = instances; // ensures atomicity
if (instancesNow == null) {
- LDConfig.log().e("LDClient.getForMobileKey() was called before init()!");
+ getSharedLogger().error("LDClient.getForMobileKey() was called before init()!");
throw new LaunchDarklyException("LDClient.getForMobileKey() was called before init()!");
}
if (!(instancesNow.containsKey(keyName))) {
@@ -253,23 +259,28 @@ protected LDClient(final Application application, @NonNull final LDConfig config
@VisibleForTesting
protected LDClient(final Application application, @NonNull final LDConfig config, final String environmentName) {
- LDConfig.log().i("Creating LaunchDarkly client. Version: %s", BuildConfig.VERSION_NAME);
+ this.logger = LDLogger.withAdapter(config.getLogAdapter(), config.getLoggerName());
+ logger.info("Creating LaunchDarkly client. Version: {}", BuildConfig.VERSION_NAME);
this.config = config;
this.application = application;
String sdkKey = config.getMobileKeys().get(environmentName);
- FeatureFetcher fetcher = HttpFeatureFlagFetcher.newInstance(application, config, environmentName);
+ FeatureFetcher fetcher = HttpFeatureFlagFetcher.newInstance(application, config, environmentName, logger);
OkHttpClient sharedEventClient = makeSharedEventClient();
if (config.getDiagnosticOptOut()) {
this.diagnosticStore = null;
this.diagnosticEventProcessor = null;
} else {
this.diagnosticStore = new DiagnosticStore(application, sdkKey);
- this.diagnosticEventProcessor = new DiagnosticEventProcessor(config, environmentName, diagnosticStore, application, sharedEventClient);
+ this.diagnosticEventProcessor = new DiagnosticEventProcessor(config, environmentName, diagnosticStore, application,
+ sharedEventClient, logger);
}
- this.userManager = DefaultUserManager.newInstance(application, fetcher, environmentName, sdkKey, config.getMaxCachedUsers());
+ this.userManager = DefaultUserManager.newInstance(application, fetcher, environmentName, sdkKey, config.getMaxCachedUsers(),
+ logger);
- eventProcessor = new DefaultEventProcessor(application, config, userManager.getSummaryEventStore(), environmentName, diagnosticStore, sharedEventClient);
- connectivityManager = new ConnectivityManager(application, config, eventProcessor, userManager, environmentName, diagnosticEventProcessor, diagnosticStore);
+ eventProcessor = new DefaultEventProcessor(application, config, userManager.getSummaryEventStore(), environmentName,
+ diagnosticStore, sharedEventClient, logger);
+ connectivityManager = new ConnectivityManager(application, config, eventProcessor, userManager, environmentName,
+ diagnosticEventProcessor, diagnosticStore, logger);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
connectivityReceiver = new ConnectivityReceiver();
@@ -311,7 +322,7 @@ public Future identify(LDUser user) {
return new LDFailedFuture<>(new LaunchDarklyException("User cannot be null"));
}
if (user.getKey() == null) {
- LDConfig.log().w("identify called with null user or null user key!");
+ logger.warn("identify called with null user or null user key!");
}
return identifyInstances(customizeUser(user));
}
@@ -442,17 +453,17 @@ private EvaluationDetail variationDetailInternal(@NonNull String key, @
LDValue value = defaultValue;
if (flag == null || flag.isDeleted()) {
- LDConfig.log().i("Unknown feature flag \"%s\"; returning default value", key);
+ logger.info("Unknown feature flag \"{}\"; returning default value", key);
result = EvaluationDetail.fromValue(defaultValue, EvaluationDetail.NO_VARIATION, EvaluationReason.error(EvaluationReason.ErrorKind.FLAG_NOT_FOUND));
} else {
value = flag.getValue();
int variation = flag.getVariation() == null ? EvaluationDetail.NO_VARIATION : flag.getVariation();
if (value.isNull()) {
- LDConfig.log().w("Feature flag \"%s\" retrieved with no value; returning default value", key);
+ logger.warn("Feature flag \"{}\" retrieved with no value; returning default value", key);
value = defaultValue;
result = EvaluationDetail.fromValue(defaultValue, variation, flag.getReason());
} else if (checkType && !defaultValue.isNull() && value.getType() != defaultValue.getType()) {
- LDConfig.log().w("Feature flag \"%s\" with type %s retrieved as %s; returning default value", key, value.getType(), defaultValue.getType());
+ logger.warn("Feature flag \"{}\" with type {} retrieved as {}; returning default value", key, value.getType(), defaultValue.getType());
value = defaultValue;
result = EvaluationDetail.fromValue(defaultValue, EvaluationDetail.NO_VARIATION, EvaluationReason.error(EvaluationReason.ErrorKind.WRONG_TYPE));
} else {
@@ -461,7 +472,7 @@ private EvaluationDetail variationDetailInternal(@NonNull String key, @
sendFlagRequestEvent(key, flag, value, defaultValue, flag.isTrackReason() | needsReason ? result.getReason() : null);
}
- LDConfig.log().d("returning variation: %s flagKey: %s user key: %s", result, key, userManager.getCurrentUser().getKey());
+ logger.debug("returning variation: {} flagKey: {} user key: {}", result, key, userManager.getCurrentUser().getKey());
updateSummaryEvents(key, flag, value, defaultValue);
return result;
}
@@ -495,6 +506,7 @@ private void closeInstances() {
for (LDClient client : oldClients) {
client.closeInternal();
}
+ sharedLogger = null;
}
@Override
@@ -673,7 +685,7 @@ private void sendEvent(Event event) {
if (!connectivityManager.isOffline()) {
boolean processed = eventProcessor.sendEvent(event);
if (!processed) {
- LDConfig.log().w("Exceeded event queue capacity. Increase capacity to avoid dropping events.");
+ logger.warn("Exceeded event queue capacity. Increase capacity to avoid dropping events.");
if (diagnosticStore != null) {
diagnosticStore.incrementDroppedEventCount();
}
@@ -700,7 +712,7 @@ private void updateSummaryEvents(String flagKey, Flag flag, LDValue result, LDVa
static void triggerPollInstances() {
if (instances == null) {
- LDConfig.log().w("Cannot perform poll when LDClient has not been initialized!");
+ getSharedLogger().warn("Cannot perform poll when LDClient has not been initialized!");
return;
}
for (LDClient instance : instances.values()) {
@@ -710,7 +722,7 @@ static void triggerPollInstances() {
static void onNetworkConnectivityChangeInstances(boolean network) {
if (instances == null) {
- LDConfig.log().e("Tried to update LDClients with network connectivity status, but LDClient has not yet been initialized.");
+ getSharedLogger().error("Tried to update LDClients with network connectivity status, but LDClient has not yet been initialized.");
return;
}
for (LDClient instance : instances.values()) {
@@ -718,6 +730,24 @@ static void onNetworkConnectivityChangeInstances(boolean network) {
}
}
+ private static void initSharedLogger(LDConfig config) {
+ synchronized (initLock) {
+ // We initialize the shared logger lazily because, until the first time init() is called, because
+ // we don't know what the log adapter should be until there's a configuration.
+ if (sharedLogger == null) {
+ sharedLogger = LDLogger.withAdapter(config.getLogAdapter(), config.getLoggerName());
+ }
+ }
+ }
+
+ static LDLogger getSharedLogger() {
+ LDLogger logger = sharedLogger;
+ if (logger != null) {
+ return logger;
+ }
+ return LDLogger.none();
+ }
+
@VisibleForTesting
SummaryEventStore getSummaryEventStore() {
return userManager.getSummaryEventStore();
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDConfig.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDConfig.java
index aece004f..e6b1e39c 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDConfig.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDConfig.java
@@ -6,20 +6,24 @@
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
+import com.launchdarkly.logging.LDLogAdapter;
+import com.launchdarkly.logging.LDLogLevel;
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.logging.Logs;
import com.launchdarkly.sdk.LDUser;
import com.launchdarkly.sdk.UserAttribute;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import okhttp3.Headers;
import okhttp3.MediaType;
-import timber.log.Timber;
-import timber.log.Timber.Tree;
/**
* This class exposes advanced configuration options for {@link LDClient}. Instances of this class
@@ -27,7 +31,9 @@
*/
public class LDConfig {
- static final String TIMBER_TAG = "LaunchDarklySdk";
+ static final String DEFAULT_LOGGER_NAME = "LaunchDarklySdk";
+ static final LDLogLevel DEFAULT_LOG_LEVEL = LDLogLevel.INFO;
+
static final String SHARED_PREFS_BASE_KEY = "LaunchDarkly-";
static final String USER_AGENT_HEADER_VALUE = "AndroidClient/" + BuildConfig.VERSION_NAME;
static final String AUTH_SCHEME = "api_key ";
@@ -87,6 +93,9 @@ public class LDConfig {
private final boolean autoAliasingOptOut;
+ private final LDLogAdapter logAdapter;
+ private final String loggerName;
+
LDConfig(Map mobileKeys,
Uri pollUri,
Uri eventsUri,
@@ -110,7 +119,9 @@ public class LDConfig {
String wrapperVersion,
int maxCachedUsers,
LDHeaderUpdater headerTransform,
- boolean autoAliasingOptOut) {
+ boolean autoAliasingOptOut,
+ LDLogAdapter logAdapter,
+ String loggerName) {
this.mobileKeys = mobileKeys;
this.pollUri = pollUri;
@@ -136,11 +147,12 @@ public class LDConfig {
this.maxCachedUsers = maxCachedUsers;
this.headerTransform = headerTransform;
this.autoAliasingOptOut = autoAliasingOptOut;
+ this.logAdapter = logAdapter;
+ this.loggerName = loggerName;
this.filteredEventGson = new GsonBuilder()
.registerTypeAdapter(LDUser.class, new LDUtil.LDUserPrivateAttributesTypeAdapter(this))
.create();
-
}
Headers headersForEnvironment(@NonNull String environmentName,
@@ -281,6 +293,10 @@ boolean isAutoAliasingOptOut() {
return autoAliasingOptOut;
}
+ LDLogAdapter getLogAdapter() { return logAdapter; }
+
+ String getLoggerName() { return loggerName; }
+
/**
* A builder that helps construct
* {@link LDConfig} objects. Builder calls can be chained, enabling the following pattern:
@@ -324,6 +340,10 @@ public static class Builder {
private LDHeaderUpdater headerTransform;
private boolean autoAliasingOptOut = false;
+ private LDLogAdapter logAdapter = defaultLogAdapter();
+ private String loggerName = DEFAULT_LOGGER_NAME;
+ private LDLogLevel logLevel = null;
+
/**
* Specifies that user attributes (other than the key) should be hidden from LaunchDarkly.
* If this is set, all user attribute values will be private, not just the attributes
@@ -682,42 +702,154 @@ public LDConfig.Builder headerTransform(LDHeaderUpdater headerTransform) {
this.headerTransform = headerTransform;
return this;
}
-
+
+ /**
+ * Specifies the implementation of logging to use.
+ *
+ * The com.launchdarkly.logging
+ * API defines the {@link LDLogAdapter} interface to specify where log output should be sent. By default,
+ * it is set to {@link LDTimberLogging#adapter()}, meaning that output will be sent to the
+ * Timber framework and controlled by whatever Timber
+ * configuration the application has created. You may change this to {@link LDAndroidLogging#adapter()}
+ * to bypass Timber and use Android native logging directly; or, use the
+ * {@link com.launchdarkly.logging.Logs} factory methods, or a custom implementation, to handle log
+ * output differently.
+ *
+ * Specifying {@code logAdapter(Logs.none())} completely disables log output.
+ *
+ * For more about logging adapters,
+ * see the SDK reference guide
+ * and the API documentation for
+ * com.launchdarkly.logging.
+ *
+ * @param logAdapter an {@link LDLogAdapter} for the desired logging implementation
+ * @return the builder
+ * @since 3.2.0
+ * @see #logLevel(LDLogLevel)
+ * @see #loggerName(String)
+ * @see LDTimberLogging
+ * @see LDAndroidLogging
+ * @see com.launchdarkly.logging.Logs
+ */
+ public LDConfig.Builder logAdapter(LDLogAdapter logAdapter) {
+ this.logAdapter = logAdapter == null ? defaultLogAdapter() : logAdapter;
+ return this;
+ }
+
+ /**
+ * Specifies the lowest level of logging to enable.
+ *
+ * This is only applicable when using an implementation of logging that does not have its own
+ * external filter/configuration mechanism, such as {@link LDAndroidLogging}. It adds
+ * a log level filter so that log messages at lower levels are suppressed. The default is
+ * {@link LDLogLevel#INFO}, meaning that {@code INFO}, {@code WARN}, and {@code ERROR} levels
+ * are enabled, but {@code DEBUG} is disabled. To enable {@code DEBUG} level as well:
+ *
+ * LDConfig config = new LDConfig.Builder()
+ * .logAdapter(LDAndroidLogging.adapter())
+ * .level(LDLogLevel.DEBUG)
+ * .build();
+ *
+ *
+ * Or, to raise the logging threshold so that only WARN and ERROR levels are enabled, and
+ * DEBUG and INFO are disabled:
+ *
+ * LDConfig config = new LDConfig.Builder()
+ * .logAdapter(LDAndroidLogging.adapter())
+ * .level(LDLogLevel.WARN)
+ * .build();
+ *
+ *
+ * When using {@link LDTimberLogging}, Timber has its own mechanism for determining whether
+ * to enable debug-level logging, so this method has no effect.
+ *
+ * @param logLevel the lowest level of logging to enable
+ * @return the builder
+ * @since 3.2.0
+ * @see #logAdapter(LDLogAdapter)
+ * @see #loggerName(String)
+ */
+ public LDConfig.Builder logLevel(LDLogLevel logLevel) {
+ this.logLevel = logLevel;
+ return this;
+ }
+
+ /**
+ * Specifies a custom logger name/tag for the SDK.
+ *
+ * When using Timber or native Android logging, this becomes the tag for all SDK log output.
+ * If you have specified a different logging implementation with {@link #logAdapter(LDLogAdapter)},
+ * the meaning of the logger name depends on the logging framework.
+ *
+ * If not specified, the default is "LaunchDarklySdk".
+ *
+ * @param loggerName the logger name or tag
+ * @return the builder
+ * @since 3.2.0
+ * @see #logAdapter(LDLogAdapter)
+ * @see #logLevel(LDLogLevel)
+ */
+ public LDConfig.Builder loggerName(String loggerName) {
+ this.loggerName = loggerName == null ? DEFAULT_LOGGER_NAME : loggerName;
+ return this;
+ }
+
+ private static LDLogAdapter defaultLogAdapter() {
+ return LDTimberLogging.adapter();
+ }
+
/**
* Returns the configured {@link LDConfig} object.
* @return the configuration
*/
public LDConfig build() {
+ LDLogAdapter actualLogAdapter = Logs.level(logAdapter,
+ logLevel == null ? DEFAULT_LOG_LEVEL : logLevel);
+ // Note: if the log adapter is LDTimberLogging, then Logs.level has no effect - we will still
+ // forward all of our logging to Timber, because it has its own mechanism for filtering out
+ // debug logging. But if it is LDAndroidLogging or anything else, Logs.level ensures that no
+ // output at a lower level than logLevel will be sent anywhere.
+
+ LDLogger logger = LDLogger.withAdapter(actualLogAdapter, loggerName);
+
if (!stream) {
if (pollingIntervalMillis < MIN_POLLING_INTERVAL_MILLIS) {
- LDConfig.log().w("setPollingIntervalMillis: %s was set below the allowed minimum of: %s. Ignoring and using minimum value.", pollingIntervalMillis, MIN_POLLING_INTERVAL_MILLIS);
+ logger.warn(
+ "setPollingIntervalMillis: {} was set below the allowed minimum of: {}. Ignoring and using minimum value.",
+ pollingIntervalMillis, MIN_POLLING_INTERVAL_MILLIS);
pollingIntervalMillis = MIN_POLLING_INTERVAL_MILLIS;
}
if (!disableBackgroundUpdating && backgroundPollingIntervalMillis < pollingIntervalMillis) {
- LDConfig.log().w("BackgroundPollingIntervalMillis: %s was set below the foreground polling interval: %s. Ignoring and using minimum value for background polling.", backgroundPollingIntervalMillis, pollingIntervalMillis);
+ logger.warn(
+ "BackgroundPollingIntervalMillis: {} was set below the foreground polling interval: {}. Ignoring and using minimum value for background polling.",
+ backgroundPollingIntervalMillis, pollingIntervalMillis);
backgroundPollingIntervalMillis = MIN_BACKGROUND_POLLING_INTERVAL_MILLIS;
}
if (eventsFlushIntervalMillis == 0) {
eventsFlushIntervalMillis = pollingIntervalMillis;
- LDConfig.log().d("Streaming is disabled, so we're setting the events flush interval to the polling interval value: %s", pollingIntervalMillis);
+ // this is a normal occurrence, so don't log a warning about it
}
}
if (!disableBackgroundUpdating) {
if (backgroundPollingIntervalMillis < MIN_BACKGROUND_POLLING_INTERVAL_MILLIS) {
- LDConfig.log().w("BackgroundPollingIntervalMillis: %s was set below the minimum allowed: %s. Ignoring and using minimum value.", backgroundPollingIntervalMillis, MIN_BACKGROUND_POLLING_INTERVAL_MILLIS);
+ logger.warn(
+ "BackgroundPollingIntervalMillis: {} was set below the minimum allowed: {}. Ignoring and using minimum value.",
+ backgroundPollingIntervalMillis, MIN_BACKGROUND_POLLING_INTERVAL_MILLIS);
backgroundPollingIntervalMillis = MIN_BACKGROUND_POLLING_INTERVAL_MILLIS;
}
}
if (eventsFlushIntervalMillis == 0) {
- eventsFlushIntervalMillis = DEFAULT_FLUSH_INTERVAL_MILLIS;
+ eventsFlushIntervalMillis = DEFAULT_FLUSH_INTERVAL_MILLIS; // this is a normal occurrence, so don't log a warning about it
}
if (diagnosticRecordingIntervalMillis < MIN_DIAGNOSTIC_RECORDING_INTERVAL_MILLIS) {
- LDConfig.log().w("diagnosticRecordingIntervalMillis was set to %s, lower than the minimum allowed (%s). Ignoring and using minimum value.", diagnosticRecordingIntervalMillis, MIN_DIAGNOSTIC_RECORDING_INTERVAL_MILLIS);
+ logger.warn(
+ "diagnosticRecordingIntervalMillis was set to %s, lower than the minimum allowed (%s). Ignoring and using minimum value.",
+ diagnosticRecordingIntervalMillis, MIN_DIAGNOSTIC_RECORDING_INTERVAL_MILLIS);
diagnosticRecordingIntervalMillis = MIN_DIAGNOSTIC_RECORDING_INTERVAL_MILLIS;
}
@@ -754,11 +886,9 @@ public LDConfig build() {
wrapperVersion,
maxCachedUsers,
headerTransform,
- autoAliasingOptOut);
+ autoAliasingOptOut,
+ actualLogAdapter,
+ loggerName);
}
}
-
- public static final Tree log() {
- return Timber.tag(TIMBER_TAG);
- }
}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDFutures.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDFutures.java
index bfa134fb..6d26dba4 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDFutures.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDFutures.java
@@ -90,7 +90,7 @@ synchronized void set(T result) {
notifier.notifyAll();
}
} else {
- LDConfig.log().w("LDAwaitFuture set twice");
+ LDClient.getSharedLogger().warn("LDAwaitFuture set twice");
}
}
@@ -102,7 +102,7 @@ synchronized void setException(@NonNull Throwable error) {
notifier.notifyAll();
}
} else {
- LDConfig.log().w("LDAwaitFuture set twice");
+ LDClient.getSharedLogger().warn("LDAwaitFuture set twice");
}
}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDTimberLogging.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDTimberLogging.java
new file mode 100644
index 00000000..5df2fbe4
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDTimberLogging.java
@@ -0,0 +1,112 @@
+package com.launchdarkly.sdk.android;
+
+import com.launchdarkly.logging.LDLogAdapter;
+import com.launchdarkly.logging.LDLogLevel;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import timber.log.Timber;
+import timber.log.Timber.DebugTree;
+import timber.log.Timber.Tree;
+
+/**
+ * Allows LaunchDarkly log output to be forwarded to Timber.
+ *
+ * Currently this is the default logging implementation; in the future, we may change the default to
+ * {@link LDAndroidLogging}.
+ *
+ * When this logging implementation is active, the SDK will automatically call
+ * {@code Timber.plant(new Timber.DebugTree)} at initialization time if and only if
+ * {@code BuildConfig.DEBUG} is true. This behavior is for consistency with the default behavior of
+ * earlier SDK versions and may be removed in the future. It can be changed with
+ * {@link Adapter#autoPlantDebugTree(boolean)}.
+ *
+ * @since 3.2.0
+ */
+public abstract class LDTimberLogging {
+ public static LDLogAdapter adapter() {
+ return new Adapter(true);
+ }
+
+ /**
+ * A Timber implementation of the {@link LDLogAdapter} interface.
+ */
+ public static final class Adapter implements LDLogAdapter, LDLogAdapter.IsConfiguredExternally {
+ // Note: implementing IsConfiguredExternally tells the logging framework that it should not
+ // try to do level filtering, because Timber has its own configuration mechanisms.
+ private final boolean autoPlantDebugTree;
+
+ Adapter(boolean autoPlantDebugTree) {
+ this.autoPlantDebugTree = autoPlantDebugTree;
+ }
+
+ /**
+ * Returns a modified logging adapter with the automatic debug tree behavior changed.
+ *
+ * By default, this property is true, meaning that the SDK will automatically call
+ * {@code Timber.plant(new Timber.DebugTree)} at initialization time if and only if
+ * {@code BuildConfig.DEBUG} is true. If you set it to false as shown below, then the
+ * SDK will never create a {@code DebugTree} and the application is responsible for
+ * doing so if desired.
+ *
+ * LDConfig config = new LDConfig.Builder()
+ * .mobileKey("mobile-key")
+ * .logAdapter(LDTimberLogging.adapter().autoPlantDebugTree(false))
+ * .build();
+ *
+ *
+ * In a future version, this automatic behavior may be removed, since it is arguably more
+ * correct for library code to leave all Tree-planting to the application. The behavior is
+ * retained in the current release for backward compatibility.
+ *
+ * @param autoPlantDebugTree true to retain the default automatic {@code DebugTree}
+ * behavior, or false to disable it
+ * @return a modified {@link Adapter} with the specified behavior
+ */
+ public Adapter autoPlantDebugTree(boolean autoPlantDebugTree) {
+ return new Adapter(autoPlantDebugTree);
+ }
+
+ @Override
+ public Channel newChannel(String name) {
+ return new ChannelImpl(name, autoPlantDebugTree);
+ }
+ }
+
+ private static final class ChannelImpl extends LDAndroidLogging.ChannelImplBase {
+ private static final AtomicBoolean inited = new AtomicBoolean(false);
+
+ ChannelImpl(String tag, boolean autoPlantDebugTree) {
+ super(tag);
+ if (autoPlantDebugTree && !inited.getAndSet(true)) {
+ if (BuildConfig.DEBUG) {
+ Timber.plant(new DebugTree());
+ }
+ }
+ }
+
+ @Override
+ public boolean isEnabled(LDLogLevel level) {
+ return true;
+ }
+
+ @Override
+ protected void logInternal(LDLogLevel level, String text) {
+ Tree tree = Timber.tag(tag);
+ switch (level) {
+ case DEBUG:
+ tree.d(text);
+ break;
+ case INFO:
+ tree.i(text);
+ break;
+ case WARN:
+ tree.w(text);
+ break;
+ case ERROR:
+ tree.e(text);
+ break;
+ }
+ }
+ }
+}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDUtil.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDUtil.java
index fbdbf9d5..c3ef2926 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDUtil.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDUtil.java
@@ -13,11 +13,15 @@
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
+import com.launchdarkly.logging.LDLogLevel;
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.logging.LogValues;
import com.launchdarkly.sdk.LDUser;
import com.launchdarkly.sdk.LDValue;
import com.launchdarkly.sdk.UserAttribute;
import java.io.IOException;
+import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@@ -75,7 +79,8 @@ static boolean isClientConnected(Context context, String environmentName) {
try {
return deviceConnected && !LDClient.getForMobileKey(environmentName).isOffline();
} catch (LaunchDarklyException e) {
- LDConfig.log().e(e, "Exception caught when getting LDClient");
+ LDClient.getSharedLogger().error("Exception caught when getting LDClient: {}", LogValues.exceptionSummary(e));
+ LDClient.getSharedLogger().debug(LogValues.exceptionTrace(e));
return false;
}
}
@@ -130,6 +135,27 @@ static boolean isHttpErrorRecoverable(int statusCode) {
return true;
}
+ static void logExceptionAtErrorLevel(LDLogger logger, Throwable ex, String msgFormat, Object... msgArgs) {
+ logException(logger, ex, true, msgFormat, msgArgs);
+ }
+
+ static void logExceptionAtWarnLevel(LDLogger logger, Throwable ex, String msgFormat, Object... msgArgs) {
+ logException(logger, ex, false, msgFormat, msgArgs);
+ }
+
+ private static void logException(LDLogger logger, Throwable ex, boolean asError, String msgFormat, Object... msgArgs) {
+ String addFormat = msgFormat + " - {}";
+ Object exSummary = LogValues.exceptionSummary(ex);
+ Object[] args = Arrays.copyOf(msgArgs, msgArgs.length + 1);
+ args[msgArgs.length] = exSummary;
+ if (asError) {
+ logger.error(addFormat, args);
+ } else {
+ logger.warn(addFormat, args);
+ }
+ logger.debug(LogValues.exceptionTrace(ex));
+ }
+
static class LDUserPrivateAttributesTypeAdapter extends TypeAdapter {
private final LDConfig config;
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/Migration.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/Migration.java
index 8bfae268..52a66789 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/Migration.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/Migration.java
@@ -7,6 +7,7 @@
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
+import com.launchdarkly.logging.LogValues;
import java.io.File;
import java.util.ArrayList;
@@ -29,7 +30,8 @@ static void migrateWhenNeeded(Application application, LDConfig config) {
try {
migrate_2_7_fresh(application, config);
} catch (Exception ex) {
- LDConfig.log().w(ex, "Exception while performing fresh v2.7.0 store migration");
+ LDUtil.logExceptionAtWarnLevel(LDClient.getSharedLogger(), ex,
+ "Exception while performing fresh v2.7.0 store migration");
}
}
@@ -37,7 +39,8 @@ static void migrateWhenNeeded(Application application, LDConfig config) {
try {
migrate_2_7_from_2_6(application);
} catch (Exception ex) {
- LDConfig.log().w(ex, "Exception while performing v2.6.0 to v2.7.0 store migration");
+ LDUtil.logExceptionAtWarnLevel(LDClient.getSharedLogger(), ex,
+ "Exception while performing v2.6.0 to v2.7.0 store migration");
}
}
}
@@ -62,7 +65,7 @@ private static String reconstructFlag(String key, String metadata, Object value)
}
private static void migrate_2_7_fresh(Application application, LDConfig config) {
- LDConfig.log().d("Migrating to v2.7.0 shared preferences store");
+ LDClient.getSharedLogger().debug("Migrating to v2.7.0 shared preferences store");
ArrayList userKeys = getUserKeysPre_2_6(application, config);
SharedPreferences versionSharedPrefs = application.getSharedPreferences(LDConfig.SHARED_PREFS_BASE_KEY + "version", Context.MODE_PRIVATE);
@@ -92,7 +95,7 @@ private static void migrate_2_7_fresh(Application application, LDConfig config)
}
if (allSuccess) {
- LDConfig.log().d("Migration to v2.7.0 shared preferences store successful");
+ LDClient.getSharedLogger().debug("Migration to v2.7.0 shared preferences store successful");
SharedPreferences migrations = application.getSharedPreferences(LDConfig.SHARED_PREFS_BASE_KEY + "migrations", Context.MODE_PRIVATE);
boolean logged = migrations.edit().putString("v2.7.0", "v2.7.0").commit();
if (logged) {
@@ -108,7 +111,7 @@ private static void migrate_2_7_fresh(Application application, LDConfig config)
}
private static void migrate_2_7_from_2_6(Application application) {
- LDConfig.log().d("Migrating to v2.7.0 shared preferences store from v2.6.0");
+ LDClient.getSharedLogger().debug("Migrating to v2.7.0 shared preferences store from v2.6.0");
Map> keyUsers = getUserKeys_2_6(application);
@@ -133,7 +136,7 @@ private static void migrate_2_7_from_2_6(Application application) {
}
if (allSuccess) {
- LDConfig.log().d("Migration to v2.7.0 shared preferences store successful");
+ LDClient.getSharedLogger().debug("Migration to v2.7.0 shared preferences store successful");
SharedPreferences migrations = application.getSharedPreferences(LDConfig.SHARED_PREFS_BASE_KEY + "migrations", Context.MODE_PRIVATE);
boolean logged = migrations.edit().putString("v2.7.0", "v2.7.0").commit();
if (logged) {
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/PollingUpdater.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/PollingUpdater.java
index 53e14be0..962434bb 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/PollingUpdater.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/PollingUpdater.java
@@ -10,6 +10,8 @@
import static android.app.PendingIntent.FLAG_IMMUTABLE;
+import com.launchdarkly.logging.LogValues;
+
/**
* Used internally by the SDK.
*/
@@ -27,13 +29,13 @@ public void onReceive(Context context, Intent intent) {
}
synchronized static void startBackgroundPolling(Context context) {
- LDConfig.log().d("Starting background polling");
+ LDClient.getSharedLogger().debug("Starting background polling");
startPolling(context, backgroundPollingIntervalMillis, backgroundPollingIntervalMillis);
}
synchronized static void startPolling(Context context, int initialDelayMillis, int intervalMillis) {
stop(context);
- LDConfig.log().d("startPolling with initialDelayMillis: %d and intervalMillis: %d", initialDelayMillis, intervalMillis);
+ LDClient.getSharedLogger().debug("startPolling with initialDelayMillis: %d and intervalMillis: %d", initialDelayMillis, intervalMillis);
PendingIntent pendingIntent = getPendingIntent(context);
AlarmManager alarmMgr = getAlarmManager(context);
@@ -44,12 +46,13 @@ synchronized static void startPolling(Context context, int initialDelayMillis, i
intervalMillis,
pendingIntent);
} catch (Exception ex) {
- LDConfig.log().w(ex, "Exception occurred when creating [background] polling alarm, likely due to the host application having too many existing alarms.");
+ LDUtil.logExceptionAtWarnLevel(LDClient.getSharedLogger(), ex,
+ "Exception occurred when creating [background] polling alarm, likely due to the host application having too many existing alarms");
}
}
synchronized static void stop(Context context) {
- LDConfig.log().d("Stopping pollingUpdater");
+ LDClient.getSharedLogger().debug("Stopping pollingUpdater");
PendingIntent pendingIntent = getPendingIntent(context);
AlarmManager alarmMgr = getAlarmManager(context);
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStore.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStore.java
index 2238aca4..ced6e69f 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStore.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStore.java
@@ -10,6 +10,7 @@
import androidx.annotation.Nullable;
import com.google.gson.Gson;
+import com.launchdarkly.logging.LDLogger;
import java.io.File;
import java.lang.ref.WeakReference;
@@ -29,12 +30,14 @@ class SharedPrefsFlagStore implements FlagStore {
private final Application application;
private SharedPreferences sharedPreferences;
private WeakReference listenerWeakReference;
+ private LDLogger logger;
- SharedPrefsFlagStore(@NonNull Application application, @NonNull String identifier) {
+ SharedPrefsFlagStore(@NonNull Application application, @NonNull String identifier, LDLogger logger) {
this.application = application;
this.prefsKey = SHARED_PREFS_BASE_KEY + identifier + "-flags";
this.sharedPreferences = application.getSharedPreferences(prefsKey, Context.MODE_PRIVATE);
this.listenerWeakReference = new WeakReference<>(null);
+ this.logger = logger;
}
@SuppressLint("ApplySharedPref")
@@ -44,7 +47,7 @@ public void delete() {
sharedPreferences = null;
File file = new File(application.getFilesDir().getParent() + "/shared_prefs/" + prefsKey + ".xml");
- LDConfig.log().i("Deleting SharedPrefs file:%s", file.getAbsolutePath());
+ logger.info("Deleting SharedPrefs file:{}", file.getAbsolutePath());
//noinspection ResultOfMethodCallIgnored
file.delete();
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreFactory.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreFactory.java
index bdc81806..5625a0f1 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreFactory.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreFactory.java
@@ -4,16 +4,20 @@
import androidx.annotation.NonNull;
+import com.launchdarkly.logging.LDLogger;
+
class SharedPrefsFlagStoreFactory implements FlagStoreFactory {
private final Application application;
+ private final LDLogger logger;
- SharedPrefsFlagStoreFactory(@NonNull Application application) {
+ SharedPrefsFlagStoreFactory(@NonNull Application application, LDLogger logger) {
this.application = application;
+ this.logger = logger;
}
@Override
public FlagStore createFlagStore(@NonNull String identifier) {
- return new SharedPrefsFlagStore(application, identifier);
+ return new SharedPrefsFlagStore(application, identifier, logger);
}
}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreManager.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreManager.java
index 36abab33..b6e13008 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreManager.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsFlagStoreManager.java
@@ -9,6 +9,8 @@
import androidx.annotation.NonNull;
+import com.launchdarkly.logging.LDLogger;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -36,17 +38,20 @@ class SharedPrefsFlagStoreManager implements FlagStoreManager, StoreUpdatedListe
private final SharedPreferences usersSharedPrefs;
private final ConcurrentHashMap> listeners;
private final CopyOnWriteArrayList allFlagsListeners;
+ private final LDLogger logger;
SharedPrefsFlagStoreManager(@NonNull Application application,
@NonNull String mobileKey,
@NonNull FlagStoreFactory flagStoreFactory,
- int maxCachedUsers) {
+ int maxCachedUsers,
+ @NonNull LDLogger logger) {
this.mobileKey = mobileKey;
this.flagStoreFactory = flagStoreFactory;
this.maxCachedUsers = maxCachedUsers;
this.usersSharedPrefs = application.getSharedPreferences(SHARED_PREFS_BASE_KEY + mobileKey + "-users", Context.MODE_PRIVATE);
this.listeners = new ConcurrentHashMap<>();
this.allFlagsListeners = new CopyOnWriteArrayList<>();
+ this.logger = logger;
}
@Override
@@ -73,7 +78,7 @@ public void switchToUser(String userKey) {
// Remove oldest users until we are at MAX_USERS.
for (int i = 0; i < usersToRemove; i++) {
String removed = oldestFirstUsers.next();
- LDConfig.log().d("Exceeded max # of users: [%s] Removing user: [%s]", maxCachedUsers, removed);
+ logger.debug("Exceeded max # of users: [{}] Removing user: [{}]", maxCachedUsers, removed);
// Load FlagStore for oldest user and delete it.
flagStoreFactory.createFlagStore(storeIdentifierForUser(removed)).delete();
// Remove entry from usersSharedPrefs.
@@ -99,9 +104,9 @@ public void registerListener(String key, FeatureFlagChangeListener listener) {
Set oldSet = listeners.putIfAbsent(key, newSet);
if (oldSet != null) {
oldSet.add(listener);
- LDConfig.log().d("Added listener. Total count: [%s]", oldSet.size());
+ logger.debug("Added listener. Total count: [{}]", oldSet.size());
} else {
- LDConfig.log().d("Added listener. Total count: 1");
+ logger.debug("Added listener. Total count: 1");
}
}
@@ -111,7 +116,7 @@ public void unRegisterListener(String key, FeatureFlagChangeListener listener) {
if (keySet != null) {
boolean removed = keySet.remove(listener);
if (removed) {
- LDConfig.log().d("Removing listener for key: [%s]", key);
+ logger.debug("Removing listener for key: [{}]", key);
}
}
}
@@ -135,9 +140,9 @@ private Collection getCachedUsers(String activeUser) {
for (String k : all.keySet()) {
try {
sortedMap.put((Long) all.get(k), k);
- LDConfig.log().d("Found user: %s", userAndTimeStampToHumanReadableString(k, (Long) all.get(k)));
+ logger.debug("Found user: {}", userAndTimeStampToHumanReadableString(k, (Long) all.get(k)));
} catch (ClassCastException cce) {
- LDConfig.log().e(cce, "Unexpected type! This is not good");
+ LDUtil.logExceptionAtErrorLevel(logger, cce, "Unexpected type! This is not good");
}
}
return sortedMap.values();
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsSummaryEventStore.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsSummaryEventStore.java
index a248bf3f..6d4af3e9 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsSummaryEventStore.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/SharedPrefsSummaryEventStore.java
@@ -4,6 +4,7 @@
import android.content.Context;
import android.content.SharedPreferences;
+import com.launchdarkly.logging.LDLogger;
import com.launchdarkly.sdk.LDValue;
import java.util.HashMap;
@@ -16,9 +17,11 @@ class SharedPrefsSummaryEventStore implements SummaryEventStore {
private static final String START_DATE_KEY = "$startDate$";
private final SharedPreferences sharedPreferences;
+ private final LDLogger logger;
- SharedPrefsSummaryEventStore(Application application, String name) {
+ SharedPrefsSummaryEventStore(Application application, String name, LDLogger logger) {
this.sharedPreferences = application.getSharedPreferences(name, Context.MODE_PRIVATE);
+ this.logger = logger;
}
@Override
@@ -49,7 +52,7 @@ public synchronized void addOrUpdateEvent(String flagResponseKey, LDValue value,
}
editor.apply();
- LDConfig.log().d("Updated summary for flagKey %s to %s", flagResponseKey, GsonCache.getGson().toJson(storedCounters));
+ logger.debug("Updated summary for flagKey {} to {}", flagResponseKey, GsonCache.getGson().toJson(storedCounters));
}
@Override
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/StreamUpdateProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/StreamUpdateProcessor.java
index 250f7bb0..238023e2 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/StreamUpdateProcessor.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/StreamUpdateProcessor.java
@@ -7,6 +7,8 @@
import com.launchdarkly.eventsource.EventSource;
import com.launchdarkly.eventsource.MessageEvent;
import com.launchdarkly.eventsource.UnsuccessfulResponseException;
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.logging.LogValues;
import com.launchdarkly.sdk.LDUser;
import java.net.URI;
@@ -43,25 +45,28 @@ class StreamUpdateProcessor {
private final LDUtil.ResultCallback notifier;
private final DiagnosticStore diagnosticStore;
private long eventSourceStarted;
+ private final LDLogger logger;
- StreamUpdateProcessor(LDConfig config, UserManager userManager, String environmentName, DiagnosticStore diagnosticStore, LDUtil.ResultCallback notifier) {
+ StreamUpdateProcessor(LDConfig config, UserManager userManager, String environmentName, DiagnosticStore diagnosticStore,
+ LDUtil.ResultCallback notifier, LDLogger logger) {
this.config = config;
this.userManager = userManager;
this.environmentName = environmentName;
this.notifier = notifier;
this.diagnosticStore = diagnosticStore;
+ this.logger = logger;
queue = new Debounce();
executor = new BackgroundThreadExecutor().newFixedThreadPool(2);
}
synchronized void start() {
if (!running && !connection401Error) {
- LDConfig.log().d("Starting.");
+ logger.debug("Starting.");
EventHandler handler = new EventHandler() {
@Override
public void onOpen() {
- LDConfig.log().i("Started LaunchDarkly EventStream");
+ logger.info("Started LaunchDarkly EventStream");
if (diagnosticStore != null) {
diagnosticStore.addStreamInit(eventSourceStarted, (int) (System.currentTimeMillis() - eventSourceStarted), false);
}
@@ -69,13 +74,13 @@ public void onOpen() {
@Override
public void onClosed() {
- LDConfig.log().i("Closed LaunchDarkly EventStream");
+ logger.info("Closed LaunchDarkly EventStream");
}
@Override
public void onMessage(final String name, MessageEvent event) {
final String eventData = event.getData();
- LDConfig.log().d("onMessage: %s: %s", name, eventData);
+ logger.debug("onMessage: {}: {}", name, eventData);
handle(name, eventData, notifier);
}
@@ -86,14 +91,16 @@ public void onComment(String comment) {
@Override
public void onError(Throwable t) {
- LDConfig.log().e(t, "Encountered EventStream error connecting to URI: %s", getUri(userManager.getCurrentUser()));
+ LDUtil.logExceptionAtErrorLevel(logger, t,
+ "Encountered EventStream error connecting to URI: {}",
+ getUri(userManager.getCurrentUser()));
if (t instanceof UnsuccessfulResponseException) {
if (diagnosticStore != null) {
diagnosticStore.addStreamInit(eventSourceStarted, (int) (System.currentTimeMillis() - eventSourceStarted), true);
}
int code = ((UnsuccessfulResponseException) t).getCode();
if (code >= 400 && code < 500) {
- LDConfig.log().e("Encountered non-retriable error: %s. Aborting connection to stream. Verify correct Mobile Key and Stream URI", code);
+ logger.error("Encountered non-retriable error: {}. Aborting connection to stream. Verify correct Mobile Key and Stream URI", code);
running = false;
notifier.onError(new LDInvalidResponseCodeFailure("Unexpected Response Code From Stream Connection", t, code, false));
if (code == 401) {
@@ -101,7 +108,7 @@ public void onError(Throwable t) {
try {
LDClient.getForMobileKey(environmentName).setOffline();
} catch (LaunchDarklyException e) {
- LDConfig.log().e(e, "Client unavailable to be set offline");
+ LDUtil.logExceptionAtErrorLevel(logger, e, "Client unavailable to be set offline");
}
}
stop(null);
@@ -148,7 +155,7 @@ public void onError(Throwable t) {
@NonNull
private RequestBody getRequestBody(@Nullable LDUser user) {
- LDConfig.log().d("Attempting to report user in stream");
+ logger.debug("Attempting to report user in stream");
return RequestBody.create(GSON.toJson(user), JSON);
}
@@ -181,13 +188,13 @@ private void handle(final String name, final String eventData,
});
break;
default:
- LDConfig.log().d("Found an unknown stream protocol: %s", name);
+ logger.debug("Found an unknown stream protocol: {}", name);
onCompleteListener.onError(new LDFailure("Unknown Stream Element Type", null, LDFailure.FailureType.UNEXPECTED_STREAM_ELEMENT_TYPE));
}
}
void stop(final LDUtil.ResultCallback onCompleteListener) {
- LDConfig.log().d("Stopping.");
+ logger.debug("Stopping.");
// We do this in a separate thread because closing the stream involves a network
// operation and we don't want to do a network operation on the main thread.
executor.execute(() -> {
@@ -204,6 +211,6 @@ private synchronized void stopSync() {
}
running = false;
es = null;
- LDConfig.log().d("Stopped.");
+ logger.debug("Stopped.");
}
-}
+}
\ No newline at end of file