Transplant the Logging system from Telecom (51b98341) · Commits · e / os / android_frameworks_base

telecomm/java/android/telecom/Log.java

+279 −79

Original line number	Diff line number	Diff line
		@@ -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,166 +37,357 @@ 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 (pii instanceof Uri) {
		Uri uri = (Uri) pii;
		String scheme = uri.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 {

		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);
		@@ -200,7 +397,6 @@ final public class Log {
		return "Uninitialized SHA1";
		}
		}
		}

		private static String encodeHex(byte[] bytes) {
		StringBuffer hex = new StringBuffer(bytes.length * 2);
		@@ -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);
		}
		}

telecomm/java/android/telecom/Logging/EventManager.java

0 → 100644

+365 −0

File added.

Preview size limit exceeded, changes collapsed.

telecomm/java/android/telecom/Logging/Session.java

0 → 100644

+223 −0

File added.

Preview size limit exceeded, changes collapsed.

telecomm/java/android/telecom/Logging/SessionManager.java

0 → 100644

+344 −0

File added.

Preview size limit exceeded, changes collapsed.

telecomm/java/android/telecom/Logging/TimedEvent.java

0 → 100644

+50 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package android.telecom.Logging;

		import java.util.Collection;
		import java.util.HashMap;
		import java.util.Map;

		/**
		* @hide
		*/
		public abstract class TimedEvent<T> {
		public abstract long getTime();
		public abstract T getKey();

		public static <T> Map<T, Double> averageTimings(Collection<? extends TimedEvent<T>> events) {
		HashMap<T, Integer> counts = new HashMap<>();
		HashMap<T, Double> result = new HashMap<>();

		for (TimedEvent<T> entry : events) {
		if (counts.containsKey(entry.getKey())) {
		counts.put(entry.getKey(), counts.get(entry.getKey()) + 1);
		result.put(entry.getKey(), result.get(entry.getKey()) + entry.getTime());
		} else {
		counts.put(entry.getKey(), 1);
		result.put(entry.getKey(), (double) entry.getTime());
		}
		}

		for (Map.Entry<T, Double> entry : result.entrySet()) {
		result.put(entry.getKey(), entry.getValue() / counts.get(entry.getKey()));
		}

		return result;
		}
		}