diff options
Diffstat (limited to 'telecomm/java/android/telecom/Log.java')
| -rw-r--r-- | telecomm/java/android/telecom/Log.java | 358 |
1 files changed, 279 insertions, 79 deletions
diff --git a/telecomm/java/android/telecom/Log.java b/telecomm/java/android/telecom/Log.java index a965342982f5..ecda3cd45f73 100644 --- a/telecomm/java/android/telecom/Log.java +++ b/telecomm/java/android/telecom/Log.java @@ -18,9 +18,15 @@ package android.telecom; import android.net.Uri; import android.os.AsyncTask; +import android.telecom.Logging.EventManager; +import android.telecom.Logging.Session; +import android.telecom.Logging.SessionManager; import android.telephony.PhoneNumberUtils; import android.text.TextUtils; +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.util.IndentingPrintWriter; + import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.IllegalFormatException; @@ -31,174 +37,364 @@ import java.util.Locale; * * @hide */ -final public class Log { +public class Log { + + private static final long EXTENDED_LOGGING_DURATION_MILLIS = 60000 * 30; // 30 minutes + + private static final int EVENTS_TO_CACHE = 10; + private static final int EVENTS_TO_CACHE_DEBUG = 20; - // Generic tag for all Telecom Framework logging - private static final String TAG = "TelecomFramework"; + // Generic tag for all Telecom logging + @VisibleForTesting + public static String TAG = "TelecomFramework"; - public static final boolean FORCE_LOGGING = false; /* STOP SHIP if true */ + private static final boolean FORCE_LOGGING = false; /* STOP SHIP if true */ public static final boolean DEBUG = isLoggable(android.util.Log.DEBUG); public static final boolean INFO = isLoggable(android.util.Log.INFO); public static final boolean VERBOSE = isLoggable(android.util.Log.VERBOSE); public static final boolean WARN = isLoggable(android.util.Log.WARN); public static final boolean ERROR = isLoggable(android.util.Log.ERROR); - private static MessageDigest sMessageDigest; - private static final Object sMessageDigestLock = new Object(); + // Used to synchronize singleton logging lazy initialization + private static final Object sSingletonSync = new Object(); + private static EventManager sEventManager; + private static SessionManager sSessionManager; - private Log() {} + /** + * Tracks whether user-activated extended logging is enabled. + */ + private static boolean sIsUserExtendedLoggingEnabled = false; - public static void initMd5Sum() { - new AsyncTask<Void, Void, Void>() { - @Override - public Void doInBackground(Void... args) { - MessageDigest md; - try { - md = MessageDigest.getInstance("SHA-1"); - } catch (NoSuchAlgorithmException e) { - md = null; - } - synchronized (sMessageDigestLock) { - sMessageDigest = md; - } - return null; - } - }.execute(); - } + /** + * The time when user-activated extended logging should be ended. Used to determine when + * extended logging should automatically be disabled. + */ + private static long sUserExtendedLoggingStopTime = 0; - public static boolean isLoggable(int level) { - return FORCE_LOGGING || android.util.Log.isLoggable(TAG, level); + private Log() { } public static void d(String prefix, String format, Object... args) { - if (DEBUG) { - android.util.Log.d(TAG, buildMessage(prefix, format, args)); + if (sIsUserExtendedLoggingEnabled) { + maybeDisableLogging(); + android.util.Slog.i(TAG, buildMessage(prefix, format, args)); + } else if (DEBUG) { + android.util.Slog.d(TAG, buildMessage(prefix, format, args)); } } public static void d(Object objectPrefix, String format, Object... args) { - if (DEBUG) { - android.util.Log.d(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + if (sIsUserExtendedLoggingEnabled) { + maybeDisableLogging(); + android.util.Slog.i(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + } else if (DEBUG) { + android.util.Slog.d(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); } } public static void i(String prefix, String format, Object... args) { if (INFO) { - android.util.Log.i(TAG, buildMessage(prefix, format, args)); + android.util.Slog.i(TAG, buildMessage(prefix, format, args)); } } public static void i(Object objectPrefix, String format, Object... args) { if (INFO) { - android.util.Log.i(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + android.util.Slog.i(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); } } public static void v(String prefix, String format, Object... args) { - if (VERBOSE) { - android.util.Log.v(TAG, buildMessage(prefix, format, args)); + if (sIsUserExtendedLoggingEnabled) { + maybeDisableLogging(); + android.util.Slog.i(TAG, buildMessage(prefix, format, args)); + } else if (VERBOSE) { + android.util.Slog.v(TAG, buildMessage(prefix, format, args)); } } public static void v(Object objectPrefix, String format, Object... args) { - if (VERBOSE) { - android.util.Log.v(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + if (sIsUserExtendedLoggingEnabled) { + maybeDisableLogging(); + android.util.Slog.i(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + } else if (VERBOSE) { + android.util.Slog.v(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); } } public static void w(String prefix, String format, Object... args) { if (WARN) { - android.util.Log.w(TAG, buildMessage(prefix, format, args)); + android.util.Slog.w(TAG, buildMessage(prefix, format, args)); } } public static void w(Object objectPrefix, String format, Object... args) { if (WARN) { - android.util.Log.w(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); + android.util.Slog.w(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args)); } } public static void e(String prefix, Throwable tr, String format, Object... args) { if (ERROR) { - android.util.Log.e(TAG, buildMessage(prefix, format, args), tr); + android.util.Slog.e(TAG, buildMessage(prefix, format, args), tr); } } public static void e(Object objectPrefix, Throwable tr, String format, Object... args) { if (ERROR) { - android.util.Log.e(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args), + android.util.Slog.e(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args), tr); } } public static void wtf(String prefix, Throwable tr, String format, Object... args) { - android.util.Log.wtf(TAG, buildMessage(prefix, format, args), tr); + android.util.Slog.wtf(TAG, buildMessage(prefix, format, args), tr); } public static void wtf(Object objectPrefix, Throwable tr, String format, Object... args) { - android.util.Log.wtf(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args), + android.util.Slog.wtf(TAG, buildMessage(getPrefixFromObject(objectPrefix), format, args), tr); } public static void wtf(String prefix, String format, Object... args) { String msg = buildMessage(prefix, format, args); - android.util.Log.wtf(TAG, msg, new IllegalStateException(msg)); + android.util.Slog.wtf(TAG, msg, new IllegalStateException(msg)); } public static void wtf(Object objectPrefix, String format, Object... args) { String msg = buildMessage(getPrefixFromObject(objectPrefix), format, args); - android.util.Log.wtf(TAG, msg, new IllegalStateException(msg)); + android.util.Slog.wtf(TAG, msg, new IllegalStateException(msg)); } /** - * Redact personally identifiable information for production users. - * If we are running in verbose mode, return the original string, otherwise - * return a SHA-1 hash of the input string. + * The ease of use methods below only act mostly as proxies to the Session and Event Loggers. + * They also control the lazy loaders of the singleton instances, which will never be loaded if + * the proxy methods aren't used. + * + * Please see each method's documentation inside of their respective implementations in the + * loggers. */ - public static String pii(Object pii) { + + public static void startSession(String shortMethodName) { + getSessionManager().startSession(shortMethodName, null); + } + + public static void startSession(String shortMethodName, String callerIdentification) { + getSessionManager().startSession(shortMethodName, callerIdentification); + } + + public static Session createSubsession() { + return getSessionManager().createSubsession(); + } + + public static void cancelSubsession(Session subsession) { + getSessionManager().cancelSubsession(subsession); + } + + public static void continueSession(Session subsession, String shortMethodName) { + getSessionManager().continueSession(subsession, shortMethodName); + } + + public static void endSession() { + getSessionManager().endSession(); + } + + public static String getSessionId() { + // If the Session logger has not been initialized, then there have been no sessions logged. + // Don't load it now! + synchronized (sSingletonSync) { + if (sSessionManager != null) { + return getSessionManager().getSessionId(); + } else { + return ""; + } + } + } + + public static void addEvent(EventManager.Loggable recordEntry, String event) { + getEventManager().event(recordEntry, event, null); + } + + public static void addEvent(EventManager.Loggable recordEntry, String event, Object data) { + getEventManager().event(recordEntry, event, data); + } + + public static void addEvent(EventManager.Loggable recordEntry, String event, String format, + Object... args) { + getEventManager().event(recordEntry, event, format, args); + } + + public static void registerEventListener(EventManager.EventListener e) { + getEventManager().registerEventListener(e); + } + + public static void addRequestResponsePair(EventManager.TimedEventPair p) { + getEventManager().addRequestResponsePair(p); + } + + public static void dumpEvents(IndentingPrintWriter pw) { + // If the Events logger has not been initialized, then there have been no events logged. + // Don't load it now! + synchronized (sSingletonSync) { + if (sEventManager != null) { + getEventManager().dumpEvents(pw); + } else { + pw.println("No Historical Events Logged."); + } + } + } + + /** + * Enable or disable extended telecom logging. + * + * @param isExtendedLoggingEnabled {@code true} if extended logging should be enabled, + * {@code false} if it should be disabled. + */ + public static void setIsExtendedLoggingEnabled(boolean isExtendedLoggingEnabled) { + // If the state hasn't changed, bail early. + if (sIsUserExtendedLoggingEnabled == isExtendedLoggingEnabled) { + return; + } + + if (sEventManager != null) { + sEventManager.changeEventCacheSize(isExtendedLoggingEnabled ? + EVENTS_TO_CACHE_DEBUG : EVENTS_TO_CACHE); + } + + sIsUserExtendedLoggingEnabled = isExtendedLoggingEnabled; + if (sIsUserExtendedLoggingEnabled) { + sUserExtendedLoggingStopTime = System.currentTimeMillis() + + EXTENDED_LOGGING_DURATION_MILLIS; + } else { + sUserExtendedLoggingStopTime = 0; + } + } + + private static EventManager getEventManager() { + // Checking for null again outside of synchronization because we only need to synchronize + // during the lazy loading of the events logger. We don't need to synchronize elsewhere. + if (sEventManager == null) { + synchronized (sSingletonSync) { + if (sEventManager == null) { + sEventManager = new EventManager(Log::getSessionId); + return sEventManager; + } + } + } + return sEventManager; + } + + private static SessionManager getSessionManager() { + // Checking for null again outside of synchronization because we only need to synchronize + // during the lazy loading of the session logger. We don't need to synchronize elsewhere. + if (sSessionManager == null) { + synchronized (sSingletonSync) { + if (sSessionManager == null) { + sSessionManager = new SessionManager(); + return sSessionManager; + } + } + } + return sSessionManager; + } + + private static MessageDigest sMessageDigest; + + static void initMd5Sum() { + new AsyncTask<Void, Void, Void>() { + @Override + public Void doInBackground(Void... args) { + MessageDigest md; + try { + md = MessageDigest.getInstance("SHA-1"); + } catch (NoSuchAlgorithmException e) { + md = null; + } + sMessageDigest = md; + return null; + } + }.execute(); + } + + public static void setTag(String tag) { + TAG = tag; + } + + /** + * If user enabled extended logging is enabled and the time limit has passed, disables the + * extended logging. + */ + private static void maybeDisableLogging() { + if (!sIsUserExtendedLoggingEnabled) { + return; + } + + if (sUserExtendedLoggingStopTime < System.currentTimeMillis()) { + sUserExtendedLoggingStopTime = 0; + sIsUserExtendedLoggingEnabled = false; + } + } + + public static boolean isLoggable(int level) { + return FORCE_LOGGING || android.util.Log.isLoggable(TAG, level); + } + + public static String piiHandle(Object pii) { if (pii == null || VERBOSE) { return String.valueOf(pii); - } if (pii instanceof Uri) { - return piiUri((Uri) pii); } - return "[" + secureHash(String.valueOf(pii).getBytes()) + "]"; - } - private static String piiUri(Uri handle) { StringBuilder sb = new StringBuilder(); - String scheme = handle.getScheme(); - if (!TextUtils.isEmpty(scheme)) { - sb.append(scheme).append(":"); - } - String value = handle.getSchemeSpecificPart(); - if (!TextUtils.isEmpty(value)) { - for (int i = 0; i < value.length(); i++) { - char c = value.charAt(i); - if (PhoneNumberUtils.isStartsPostDial(c)) { - sb.append(c); - } else if (PhoneNumberUtils.isDialable(c)) { - sb.append("*"); - } else if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')) { - sb.append("*"); - } else { + if (pii instanceof Uri) { + Uri uri = (Uri) pii; + String scheme = uri.getScheme(); + + if (!TextUtils.isEmpty(scheme)) { + sb.append(scheme).append(":"); + } + + String textToObfuscate = uri.getSchemeSpecificPart(); + if (PhoneAccount.SCHEME_TEL.equals(scheme)) { + for (int i = 0; i < textToObfuscate.length(); i++) { + char c = textToObfuscate.charAt(i); + sb.append(PhoneNumberUtils.isDialable(c) ? "*" : c); + } + } else if (PhoneAccount.SCHEME_SIP.equals(scheme)) { + for (int i = 0; i < textToObfuscate.length(); i++) { + char c = textToObfuscate.charAt(i); + if (c != '@' && c != '.') { + c = '*'; + } sb.append(c); } + } else { + sb.append(pii(pii)); } } + return sb.toString(); + } + /** + * Redact personally identifiable information for production users. + * If we are running in verbose mode, return the original string, otherwise + * return a SHA-1 hash of the input string. + */ + public static String pii(Object pii) { + if (pii == null || VERBOSE) { + return String.valueOf(pii); + } + return "[" + secureHash(String.valueOf(pii).getBytes()) + "]"; } private static String secureHash(byte[] input) { - synchronized (sMessageDigestLock) { - if (sMessageDigest != null) { - sMessageDigest.reset(); - sMessageDigest.update(input); - byte[] result = sMessageDigest.digest(); - return encodeHex(result); - } else { - return "Uninitialized SHA1"; - } + if (sMessageDigest != null) { + sMessageDigest.reset(); + sMessageDigest.update(input); + byte[] result = sMessageDigest.digest(); + return encodeHex(result); + } else { + return "Uninitialized SHA1"; } } @@ -221,15 +417,19 @@ final public class Log { } private static String buildMessage(String prefix, String format, Object... args) { + // Incorporate thread ID and calling method into prefix + String sessionName = getSessionId(); + String sessionPostfix = TextUtils.isEmpty(sessionName) ? "" : ": " + sessionName; + String msg; try { msg = (args == null || args.length == 0) ? format : String.format(Locale.US, format, args); } catch (IllegalFormatException ife) { - wtf("Log", ife, "IllegalFormatException: formatString='%s' numArgs=%d", format, + e("Log", ife, "IllegalFormatException: formatString='%s' numArgs=%d", format, args.length); msg = format + " (An error occurred while formatting the message.)"; } - return String.format(Locale.US, "%s: %s", prefix, msg); + return String.format(Locale.US, "%s: %s%s", prefix, msg, sessionPostfix); } } |