31

I include this ProGuard configuration to strip out debug log statements when I release an Android application:

-assumenosideeffects class android.util.Log { public static *** d(...); public static *** v(...); }

This works as expected — I can see from the ProGuard logs and Android log output that calls such as Log.d("This is a debug statement"); are removed.

However, if I decompile the app at this stage, I can still see all the String literals that were used — i.e. This is a debug statement in this example.

Is there a way to also remove each String that's no longer needed from the bytecode?

Improve this question
4
  • Does this work along with -dontoptimize because Android documentation says "Adding optimization introduces certain risks, since for example not all optimizations performed by ProGuard works on all versions of Dalvik." Commented Sep 9, 2012 at 2:59
  • @codingcrow Probably not since, as far as I'm aware, this is an optimisation. But I believe the default Android ProGuard config has optimisation enabled in general, but disables some specific optimisations that they believe don't work reliably. So you should be able to add this to the default config without issue. Commented Sep 9, 2012 at 21:16
  • 1
    If you look at project.properties you will find the line proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt and in progaurd-android.txt you will find Optimization is turned off by default. Dex does not like code run # through the ProGuard optimize and preverify steps. So it is a catch-22 situation. Commented Sep 9, 2012 at 22:55
  • 2
    Ok, so it's not the default. But you can use the bundled proguard-android-optimize.txt config instead. Commented Sep 10, 2012 at 10:59

4 Answers 4

Reset to default
50

ProGuard can remove simple constant arguments (Strings, integers, etc). So in this case, the code and the string constant should disappear completely:

Log.d("This is a debug statement");

However, you may have observed the issue with some code like this:

Log.d("The answer is "+answer);

After compilation, this actually corresponds to:

Log.d(new StringBuilder().append("The answer is ").append(answer).toString());

ProGuard version 4.6 can simplify this to something like:

new StringBuilder().append("The answer is ").append(answer).toString();

So the logging is gone, but the optimization step still leaves some fluff behind. It's surprisingly tricky to simplify this without some deeper knowledge about the StringBuilder class. As far as ProGuard is concerned, it could say:

new DatabaseBuilder().setup("MyDatabase").initialize(table).close();

For a human, the StringBuilder code can obviously be removed, but the DatabaseBuilder code probably can't. ProGuard requires escape analysis and a few other techniques, which aren't in this version yet.

As for a solution: you can create additional debug methods that take simple arguments, and let ProGuard remove those:

MyLog.d("The answer is ", answer);

Alternatively, you can try prefixing every debug statement with a condition that ProGuard can later evaluate as false. This option may be a bit more convoluted, requiring some additional -assumenosideeffects option on an initialization method for the debug flag.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

thanks for the detailed answer. Adding -assumenosideeffects StringBuilder { append(String); append(...); toString(); } seems to be effective at removing the now-unreferenced StringBuilders. Am I missing some reason why this would be bad? :)
@Christopher The append methods do have side-effects: they extend the StringBuilder instances, even if the return values are not used. Such a configuration may therefore remove occurrences that are required. It might work, but it's pretty risky.
Ah ok.. for example I could call sb.append("x"), not use the returned StringBuilder, then call foo(sb) -- but "x" wouldn't have been appended because that method invocation was removed?
This is really a good approach, and I don't understand why the framework doesn't provide log methods with string formatting. It actually doesn't make sense to build a String (sometimes complex with String.format) to eventually drop it because it does not reach the minimum log level
@rds use SLF4J it has very flexible API like: LOG.warn("{} did {}", this, "something", ex), notice that ex does not have a corresponding {} so the stacktrace will be printed. You also don't have to worry about using the proper % pattern or StringBuilder.
|
6

here is how we do it - using ant task

<target name="base.removelogs"> <replaceregexp byline="true"> <regexp pattern="Log.d\s*\(\s*\)\s*;"/> <substitution expression="{};"/> <fileset dir="src/"><include name="**/*.java"/></fileset> </replaceregexp> </target>
Improve this answer

4 Comments

Interesting, but I'm asking a more general ProGuard question here :)
good method. But how about if there were break lines in the Log.d method calling?
@qiuping345, try adding "(?s)Log.d...
@nir, how does \(\s*\) match any logging? It means "whitespace between parentheses"
5

As I don't have enough rep to comment the ant task answer directly, here some corrections for it as it proves to be very helpful in combination with a CI-Server like Jenkins who can execute it for a release build:

<target name="removelogs"> <replaceregexp byline="true"> <regexp pattern="\s*Log\.d\s*\(.*\)\s*;"/> <substitution expression="{};"/> <fileset dir="src"> <include name="**/*.java"/> </fileset> </replaceregexp> </target>

The '.' after Log must be escaped and a '.' inside of the brackets targets any logging statement, not just whitespaces as '\s*' does.

As I don't have much experience with RegEx I hope this will help some people in the same situation to get this ant task working (e.g. on Jenkins).

Improve this answer

2 Comments

Again, not related to the actual question. Presumably this doesn't work if your logging statement spans more than one line?
@ChristopherOrr, you are right, but it's possible if that's a real Java pattern: "(?s)Log\.d....
0

If you want to support multiline log calls, you can use this regexp instead:

(android\.util\.)*Log\.@([ewidv]|wtf)\s*\([\S\s]*?\)\s*;

You should be able to use this within an ant replaceregexp task like so:

<replaceregexp> <regexp pattern="((android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;)"/> <substitution expression="if(false){\1}"/> <fileset dir="src/"> <include name="**/*.java"/> </fileset> </replaceregexp>

Note: this surrounds the Log calls with if(false){ and } so the original call is preserved, both for reference and to preserve line numbers when inspecting the intermediate build files, letting the java compiler strip the calls during compilation.

If you prefer to remove the log calls completely, you could do so like this:

<replaceregexp> <regexp pattern="(android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;"/> <substitution expression=""/> <fileset dir="src/"> <include name="**/*.java"/> </fileset> </replaceregexp>

You could also apply the regular expression as a filter within a <copy> task like so:

<copy ...> <fileset ... /> <filterchain> <tokenfilter if:true="${strip.log.calls}"> <stringtokenizer delims=";" includeDelims="true"/> <replaceregex pattern="((android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;)" replace="if(false){\1}"/> </tokenfilter> </filterchain> <!-- other-filters-etc --> </copy>
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.