server/wifi/LogcatLog.java

/*
 * 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 com.android.server.wifi;

import android.util.Log;

import com.android.internal.annotations.Immutable;
import com.android.internal.annotations.VisibleForTesting;

import javax.annotation.concurrent.ThreadSafe;

/**
 * Provides a WifiLog implementation which uses logd as the
 * logging backend.
 *
 * This class is trivially thread-safe, as instances are immutable.
 * Note, however, that LogMessage instances are _not_ thread-safe.
 */
@ThreadSafe
@Immutable
class LogcatLog implements WifiLog {
    private final String mTag;
    private static volatile boolean sVerboseLogging = false;
    private static final DummyLogMessage sDummyLogMessage = new DummyLogMessage();

    LogcatLog(String tag) {
        mTag = tag;
    }

    public static void enableVerboseLogging(int verboseMode) {
        if (verboseMode > 0) {
            sVerboseLogging = true;
        } else {
            sVerboseLogging = false;
        }
    }

    /* New-style methods */
    @Override
    public LogMessage err(String format) {
        return new RealLogMessage(Log.ERROR, mTag, format);
    }

    @Override
    public LogMessage warn(String format) {
        return new RealLogMessage(Log.WARN, mTag, format);
    }

    @Override
    public LogMessage info(String format) {
        return new RealLogMessage(Log.INFO, mTag, format);
    }

    @Override
    public LogMessage trace(String format) {
        if (sVerboseLogging) {
            return new RealLogMessage(Log.DEBUG, mTag, format,
                    getNameOfCallingMethod(0));
        } else {
            return sDummyLogMessage;
        }
    }

    @Override
    public LogMessage trace(String format, int numFramesToIgnore) {
        if (sVerboseLogging) {
            return new RealLogMessage(Log.DEBUG, mTag, format,
                    getNameOfCallingMethod(numFramesToIgnore));
        } else {
            return sDummyLogMessage;
        }
    }

    @Override
    public LogMessage dump(String format) {
        if (sVerboseLogging) {
            return new RealLogMessage(Log.VERBOSE, mTag, format);
        } else {
            return sDummyLogMessage;
        }
    }

    @Override
    public void eC(String msg) {
        Log.e(mTag, msg);
    }

    @Override
    public void wC(String msg) {
        Log.w(mTag, msg);
    }

    @Override
    public void iC(String msg) {
        Log.i(mTag, msg);
    }

    @Override
    public void tC(String msg) {
        Log.d(mTag, msg);
    }

    /* Legacy methods */
    @Override
    public void e(String msg) {
        Log.e(mTag, msg);
    }

    @Override
    public void w(String msg) {
        Log.w(mTag, msg);
    }

    @Override
    public void i(String msg) {
        Log.i(mTag, msg);
    }

    @Override
    public void d(String msg) {
        Log.d(mTag, msg);
    }

    @Override
    public void v(String msg) {
        Log.v(mTag, msg);
    }

    /* Internal details */
    private static class RealLogMessage implements WifiLog.LogMessage {
        private final int mLogLevel;
        private final String mTag;
        private final String mFormat;
        private final StringBuilder mStringBuilder;
        private int mNextFormatCharPos;

        RealLogMessage(int logLevel, String tag, String format) {
            this(logLevel, tag, format, null);
        }

        RealLogMessage(int logLevel, String tag, String format, String prefix) {
            mLogLevel = logLevel;
            mTag = tag;
            mFormat = format;
            mStringBuilder = new StringBuilder();
            mNextFormatCharPos = 0;
            if (prefix != null) {
                mStringBuilder.append(prefix).append(" ");
            }
        }

        @Override
        public WifiLog.LogMessage r(String value) {
            // Since the logcat back-end is just transitional, we don't attempt to tag sensitive
            // information in it.
            return c(value);
        }

        @Override
        public WifiLog.LogMessage c(String value) {
            copyUntilPlaceholder();
            if (mNextFormatCharPos < mFormat.length()) {
                mStringBuilder.append(value);
                ++mNextFormatCharPos;
            }
            return this;
        }

        @Override
        public WifiLog.LogMessage c(long value) {
            copyUntilPlaceholder();
            if (mNextFormatCharPos < mFormat.length()) {
                mStringBuilder.append(value);
                ++mNextFormatCharPos;
            }
            return this;
        }

        @Override
        public WifiLog.LogMessage c(char value) {
            copyUntilPlaceholder();
            if (mNextFormatCharPos < mFormat.length()) {
                mStringBuilder.append(value);
                ++mNextFormatCharPos;
            }
            return this;
        }

        @Override
        public WifiLog.LogMessage c(boolean value) {
            copyUntilPlaceholder();
            if (mNextFormatCharPos < mFormat.length()) {
                mStringBuilder.append(value);
                ++mNextFormatCharPos;
            }
            return this;
        }

        @Override
        public void flush() {
            if (mNextFormatCharPos < mFormat.length()) {
                mStringBuilder.append(mFormat, mNextFormatCharPos, mFormat.length());
            }
            Log.println(mLogLevel, mTag, mStringBuilder.toString());
        }

        @VisibleForTesting
        public String toString() {
            return mStringBuilder.toString();
        }

        private void copyUntilPlaceholder() {
            if (mNextFormatCharPos >= mFormat.length()) {
                return;
            }

            int placeholderPos = mFormat.indexOf(WifiLog.PLACEHOLDER, mNextFormatCharPos);
            if (placeholderPos == -1) {
                placeholderPos = mFormat.length();
            }

            mStringBuilder.append(mFormat, mNextFormatCharPos, placeholderPos);
            mNextFormatCharPos = placeholderPos;
        }
    }

    private static final String[] TRACE_FRAMES_TO_IGNORE = {
            "getNameOfCallingMethod()", "trace()"
    };
    private String getNameOfCallingMethod(int callerFramesToIgnore) {
        final int frameNumOfInterest = callerFramesToIgnore + TRACE_FRAMES_TO_IGNORE.length;
        // In some environments, it's much faster to get a stack trace from a Throwable
        // https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6375302.
        //
        // While Dalvik optimizes the same-thread-stack-trace case,
        // Throwable_nativeGetStackTrace() is still simpler than
        // VMStack_getThreadStackTrace().
        //
        // Some crude benchmarking suggests that the cost of this approach is about
        // 50 usec. go/logcatlog-trace-benchmark
        StackTraceElement[] stackTrace = (new Throwable()).getStackTrace();
        try {
            return stackTrace[frameNumOfInterest].getMethodName();
        } catch (ArrayIndexOutOfBoundsException e) {
            return ("<unknown>");
        }
    }
}