user/src/com/google/gwt/logging/server/StackTraceDeobfuscator.java - gwt - Git at Google

 /*
  * Copyright 2010 Google Inc.
  *
  * 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.google.gwt.logging.server;

 import com.google.gwt.thirdparty.debugging.sourcemap.SourceMapConsumerFactory;
 import com.google.gwt.thirdparty.debugging.sourcemap.SourceMapping;
 import com.google.gwt.thirdparty.debugging.sourcemap.proto.Mapping;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Scanner;
 import java.util.logging.LogRecord;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /**
  * Deobfuscates stack traces on the server side. This class requires that you have turned on
  * emulated stack traces, via <code>&lt;set-property name="compiler.stackMode" value="emulated"
  * /&gt;</code> in your <code>.gwt.xml</code> module file for non-Chrome browsers or
  * <code>&lt;set-property name="compiler.useSourceMaps" value="true"/&gt;</code> for Chrome, and
  * moved your symbol map files to a location accessible by your server sever side code. You can use
  * the GWT compiler <code>-deploy</code> command line argument to specify the location of the folder
  * into which the generated <code>symbolMaps</code> directory is written. By default, the final
  * <code>symbolMaps</code> directory is <code>war/WEB-INF/deploy/<i>yourmodulename</i>/symbolMaps/</code>.
  * Pass the resulting directory location into this class' {@link StackTraceDeobfuscator#symbolMapsDirectory}
  * constructor or {@link #setSymbolMapsDirectory(String)} setter method.
  *
  * TODO(unnurg): Combine this code with similar code in JUnitHostImpl
  */
 public class StackTraceDeobfuscator {

   private static class SymbolMap extends HashMap<String, String> {
   }

   // From JsniRef class, which is in gwt-dev and so can't be accessed here
   // TODO(unnurg) once there is a place for shared code, move this to there.
   private static Pattern JsniRefPattern =
       Pattern.compile("@?([^:]+)::([^(]+)(\\((.*)\\))?");

   // The javadoc for StackTraceElement.getLineNumber() says it returns -1 when
   // the line number is unavailable
   private static final int LINE_NUMBER_UNKNOWN = -1;

   Pattern fragmentIdPattern = Pattern.compile(".*(\\d+)\\.js");

   protected File symbolMapsDirectory;

   // Map of strongName + fragmentId to sourceMap
   private Map<String, SourceMapping> sourceMaps =
       new HashMap<String, SourceMapping>();

   private Map<String, SymbolMap> symbolMaps =
       new HashMap<String, SymbolMap>();

   /**
    * Constructor, which takes a <code>symbolMaps</code> directory as its argument. Symbol maps are
    * generated into the location specified by the GWT compiler <code>-deploy</code> command line
    * argument.
    *
    * @param symbolMapsDirectory the <code>symbolMaps</code> directory with, or without trailing
    *                            directory separator character
    */
   public StackTraceDeobfuscator(String symbolMapsDirectory) {
     setSymbolMapsDirectory(symbolMapsDirectory);
   }

   /**
    * Best effort resymbolization of a log record's stack trace.
    *
    * @param lr         the log record to resymbolize
    * @param strongName the GWT permutation strong name
    * @return the best effort resymbolized log record
    */
   public LogRecord deobfuscateLogRecord(LogRecord lr, String strongName) {
     if (lr.getThrown() != null && strongName != null) {
       lr.setThrown(deobfuscateThrowable(lr.getThrown(), strongName));
     }
     return lr;
   }

   /**
    * Convenience method which resymbolizes an entire stack trace to extent possible.
    *
    * @param st         the stack trace to resymbolize
    * @param strongName the GWT permutation strong name
    * @return a best effort resymbolized stack trace
    */
   public StackTraceElement[] deobfuscateStackTrace(
       StackTraceElement[] st, String strongName) {
     StackTraceElement[] newSt = new StackTraceElement[st.length];
     for (int i = 0; i < st.length; i++) {
       newSt[i] = resymbolize(st[i], strongName);
     }
     return newSt;
   }

   /**
    * Best effort resymbolization of a a single stack trace element.
    *
    * @param ste        the stack trace element to resymbolize
    * @param strongName the GWT permutation strong name
    * @return the best effort resymbolized stack trace element
    */
   public StackTraceElement resymbolize(StackTraceElement ste,
       String strongName) {
     String declaringClass = null;
     String methodName = null;
     String filename = null;
     int lineNumber = -1;
     int fragmentId = -1;

     String steFilename = ste.getFileName();
     SymbolMap map = loadSymbolMap(strongName);
     String symbolData = map == null ? null : map.get(ste.getMethodName());

     boolean sourceMapCapable = false;

     int column = 1;
     // column information is encoded in filename after '@' for sourceMap capable browsers
     if (steFilename != null) {
       int columnMarkerIndex = steFilename.indexOf("@");
       if (columnMarkerIndex != -1) {
         try {
           column = Integer.parseInt(steFilename.substring(columnMarkerIndex + 1));
           sourceMapCapable = true;
         } catch (NumberFormatException nfe) {
         }
         steFilename = steFilename.substring(0, columnMarkerIndex);
       }
     }

     // first use symbolMap, then refine via sourceMap if possible
     if (symbolData != null) {
       // jsniIdent, className, memberName, sourceUri, sourceLine, fragmentId
       String[] parts = symbolData.split(",");
       if (parts.length == 6) {
         String[] ref = parse(
             parts[0].substring(0, parts[0].lastIndexOf(')') + 1));

         if (ref != null) {
           declaringClass = ref[0];
           methodName = ref[1];
         } else {
           declaringClass = ste.getClassName();
           methodName = ste.getMethodName();
         }

         // parts[3] contains the source file URI or "Unknown"
         filename = "Unknown".equals(parts[3]) ? null
             : parts[3].substring(parts[3].lastIndexOf('/') + 1);

         lineNumber = ste.getLineNumber();

         /*
          * When lineNumber is LINE_NUMBER_UNKNOWN, either because
          * compiler.stackMode is not emulated or
          * compiler.emulatedStack.recordLineNumbers is false, use the method
          * declaration line number from the symbol map.
          */
         if (lineNumber == LINE_NUMBER_UNKNOWN || (sourceMapCapable && column == -1)) {
           // Safari will send line numbers, with col == -1, we need to use symbolMap in this case
           lineNumber = Integer.parseInt(parts[4]);
         }

         fragmentId = Integer.parseInt(parts[5]);
       }
     }

     // anonymous function, try to use <fragmentNum>.js:line to determine fragment id
     if (fragmentId == -1 && steFilename != null) {
       // fragment identifier encoded in filename
       Matcher matcher = fragmentIdPattern.matcher(steFilename);
       if (matcher.matches()) {
         String fragment = matcher.group(1);
         try {
           fragmentId = Integer.parseInt(fragment);
         } catch (Exception e) {
         }
       } else if (steFilename.contains(strongName)) {
         // else it's <strongName>.cache.js which is the 0th fragment
         fragmentId = 0;
       }
     }


     int jsLineNumber = ste.getLineNumber();

     // try to refine location via sourcemap
     if (sourceMapCapable && fragmentId != -1 && column != -1) {
       SourceMapping sourceMapping = loadSourceMap(strongName, fragmentId);
       if (sourceMapping != null && ste.getLineNumber() > -1) {
         Mapping.OriginalMapping mappingForLine = sourceMapping
             .getMappingForLine(jsLineNumber, column);
         if (mappingForLine != null) {

           if (declaringClass == null || declaringClass.equals(ste.getClassName())) {
             declaringClass = mappingForLine.getOriginalFile();
             methodName = mappingForLine.getIdentifier();
           }
           filename = mappingForLine.getOriginalFile();
           lineNumber = mappingForLine.getLineNumber();
         }
       }
     }

     if (declaringClass != null) {
       return new StackTraceElement(declaringClass, methodName, filename, lineNumber);
     }

     // If anything goes wrong, just return the unobfuscated element
     return ste;
   }

   public void setSymbolMapsDirectory(String symbolMapsDirectory) {
     // permutations are unique, no need to clear the symbolMaps hash map
     this.symbolMapsDirectory = new File(symbolMapsDirectory);
   }

   protected InputStream getSourceMapInputStream(String permutationStrongName, int fragmentNumber)
       throws IOException {
     String filename = symbolMapsDirectory.getCanonicalPath()
         + File.separatorChar + permutationStrongName + "_sourceMap" + fragmentNumber + ".json";
     return new FileInputStream(filename);
   }

   /**
    * Retrieves a new {@link InputStream} for the given permutation strong name. This implementation,
    * which subclasses may override, returns a {@link InputStream} for the <code>
    * <i>permutation-strong-name</i>.symbolMap</code> file in the <code>symbolMaps</code> directory.
    *
    * @param permutationStrongName the GWT permutation strong name
    * @return a new {@link InputStream}
    */
   protected InputStream getSymbolMapInputStream(String permutationStrongName)
       throws IOException {
     String filename = symbolMapsDirectory.getCanonicalPath()
         + File.separatorChar + permutationStrongName + ".symbolMap";
     return new FileInputStream(filename);
   }

   private Throwable deobfuscateThrowable(Throwable old, String strongName) {
     Throwable t = new Throwable(old.getMessage());
     if (old.getStackTrace() != null) {
       t.setStackTrace(deobfuscateStackTrace(old.getStackTrace(), strongName));
     } else {
       t.setStackTrace(new StackTraceElement[0]);
     }
     if (old.getCause() != null) {
       t.initCause(deobfuscateThrowable(old.getCause(), strongName));
     }
     return t;
   }

   private SourceMapping loadSourceMap(String permutationStrongName, int fragmentId) {
     SourceMapping toReturn = sourceMaps.get(permutationStrongName + fragmentId);
     if (toReturn == null) {
       try {
         String sourceMapString = loadStreamAsString(
             getSourceMapInputStream(permutationStrongName, fragmentId));
         toReturn = SourceMapConsumerFactory.parse(sourceMapString);
         sourceMaps.put(permutationStrongName + fragmentId, toReturn);
       } catch (Exception e) {
       }
     }
     return toReturn;
   }

   private String loadStreamAsString(InputStream stream) {
     return new Scanner(stream).useDelimiter("\\A").next();
   }

   private SymbolMap loadSymbolMap(
       String strongName) {
     SymbolMap toReturn = symbolMaps.get(strongName);
     if (toReturn != null) {
       return toReturn;
     }
     toReturn = new SymbolMap();
     String line;

     try {
       BufferedReader bin = new BufferedReader(
           new InputStreamReader(getSymbolMapInputStream(strongName)));
       try {
         while ((line = bin.readLine()) != null) {
           if (line.charAt(0) == '#') {
             continue;
           }
           int idx = line.indexOf(',');
           toReturn.put(new String(line.substring(0, idx)),
               line.substring(idx + 1));
         }
       } finally {
         bin.close();
       }
     } catch (IOException e) {
       //  use empty symbol map to avoid repeated lookups
       toReturn = new SymbolMap();
     }

     symbolMaps.put(strongName, toReturn);
     return toReturn;
   }

   /**
    * Extracts the declaring class and method name from a JSNI ref, or null if the information cannot
    * be extracted.
    *
    * @param refString symbol map reference string
    * @return a string array contains the declaring class and method name, or null when the regex
    *         match fails
    * @see com.google.gwt.dev.util.JsniRef
    */
   private String[] parse(String refString) {
     Matcher matcher = JsniRefPattern.matcher(refString);
     if (!matcher.matches()) {
       return null;
     }
     String className = matcher.group(1);
     String memberName = matcher.group(2);
     String[] toReturn = new String[]{className, memberName};
     return toReturn;
   }
 }
	/*
	* Copyright 2010 Google Inc.
	*
	* 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.google.gwt.logging.server;

	import com.google.gwt.thirdparty.debugging.sourcemap.SourceMapConsumerFactory;
	import com.google.gwt.thirdparty.debugging.sourcemap.SourceMapping;
	import com.google.gwt.thirdparty.debugging.sourcemap.proto.Mapping;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.Scanner;
	import java.util.logging.LogRecord;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	/**
	* Deobfuscates stack traces on the server side. This class requires that you have turned on
	* emulated stack traces, via <code><set-property name="compiler.stackMode" value="emulated"
	* /></code> in your <code>.gwt.xml</code> module file for non-Chrome browsers or
	* <code><set-property name="compiler.useSourceMaps" value="true"/></code> for Chrome, and
	* moved your symbol map files to a location accessible by your server sever side code. You can use
	* the GWT compiler <code>-deploy</code> command line argument to specify the location of the folder
	* into which the generated <code>symbolMaps</code> directory is written. By default, the final
	* <code>symbolMaps</code> directory is <code>war/WEB-INF/deploy/<i>yourmodulename</i>/symbolMaps/</code>.
	* Pass the resulting directory location into this class' {@link StackTraceDeobfuscator#symbolMapsDirectory}
	* constructor or {@link #setSymbolMapsDirectory(String)} setter method.
	*
	* TODO(unnurg): Combine this code with similar code in JUnitHostImpl
	*/
	public class StackTraceDeobfuscator {

	private static class SymbolMap extends HashMap<String, String> {
	}

	// From JsniRef class, which is in gwt-dev and so can't be accessed here
	// TODO(unnurg) once there is a place for shared code, move this to there.
	private static Pattern JsniRefPattern =
	Pattern.compile("@?([^:]+)::([^(]+)(\\((.*)\\))?");

	// The javadoc for StackTraceElement.getLineNumber() says it returns -1 when
	// the line number is unavailable
	private static final int LINE_NUMBER_UNKNOWN = -1;

	Pattern fragmentIdPattern = Pattern.compile(".*(\\d+)\\.js");

	protected File symbolMapsDirectory;

	// Map of strongName + fragmentId to sourceMap
	private Map<String, SourceMapping> sourceMaps =
	new HashMap<String, SourceMapping>();

	private Map<String, SymbolMap> symbolMaps =
	new HashMap<String, SymbolMap>();

	/**
	* Constructor, which takes a <code>symbolMaps</code> directory as its argument. Symbol maps are
	* generated into the location specified by the GWT compiler <code>-deploy</code> command line
	* argument.
	*
	* @param symbolMapsDirectory the <code>symbolMaps</code> directory with, or without trailing
	* directory separator character
	*/
	public StackTraceDeobfuscator(String symbolMapsDirectory) {
	setSymbolMapsDirectory(symbolMapsDirectory);
	}

	/**
	* Best effort resymbolization of a log record's stack trace.
	*
	* @param lr the log record to resymbolize
	* @param strongName the GWT permutation strong name
	* @return the best effort resymbolized log record
	*/
	public LogRecord deobfuscateLogRecord(LogRecord lr, String strongName) {
	if (lr.getThrown() != null && strongName != null) {
	lr.setThrown(deobfuscateThrowable(lr.getThrown(), strongName));
	}
	return lr;
	}

	/**
	* Convenience method which resymbolizes an entire stack trace to extent possible.
	*
	* @param st the stack trace to resymbolize
	* @param strongName the GWT permutation strong name
	* @return a best effort resymbolized stack trace
	*/
	public StackTraceElement[] deobfuscateStackTrace(
	StackTraceElement[] st, String strongName) {
	StackTraceElement[] newSt = new StackTraceElement[st.length];
	for (int i = 0; i < st.length; i++) {
	newSt[i] = resymbolize(st[i], strongName);
	}
	return newSt;
	}

	/**
	* Best effort resymbolization of a a single stack trace element.
	*
	* @param ste the stack trace element to resymbolize
	* @param strongName the GWT permutation strong name
	* @return the best effort resymbolized stack trace element
	*/
	public StackTraceElement resymbolize(StackTraceElement ste,
	String strongName) {
	String declaringClass = null;
	String methodName = null;
	String filename = null;
	int lineNumber = -1;
	int fragmentId = -1;

	String steFilename = ste.getFileName();
	SymbolMap map = loadSymbolMap(strongName);
	String symbolData = map == null ? null : map.get(ste.getMethodName());

	boolean sourceMapCapable = false;

	int column = 1;
	// column information is encoded in filename after '@' for sourceMap capable browsers
	if (steFilename != null) {
	int columnMarkerIndex = steFilename.indexOf("@");
	if (columnMarkerIndex != -1) {
	try {
	column = Integer.parseInt(steFilename.substring(columnMarkerIndex + 1));
	sourceMapCapable = true;
	} catch (NumberFormatException nfe) {
	}
	steFilename = steFilename.substring(0, columnMarkerIndex);
	}
	}

	// first use symbolMap, then refine via sourceMap if possible
	if (symbolData != null) {
	// jsniIdent, className, memberName, sourceUri, sourceLine, fragmentId
	String[] parts = symbolData.split(",");
	if (parts.length == 6) {
	String[] ref = parse(
	parts[0].substring(0, parts[0].lastIndexOf(')') + 1));

	if (ref != null) {
	declaringClass = ref[0];
	methodName = ref[1];
	} else {
	declaringClass = ste.getClassName();
	methodName = ste.getMethodName();
	}

	// parts[3] contains the source file URI or "Unknown"
	filename = "Unknown".equals(parts[3]) ? null
	: parts[3].substring(parts[3].lastIndexOf('/') + 1);

	lineNumber = ste.getLineNumber();

	/*
	* When lineNumber is LINE_NUMBER_UNKNOWN, either because
	* compiler.stackMode is not emulated or
	* compiler.emulatedStack.recordLineNumbers is false, use the method
	* declaration line number from the symbol map.
	*/
	if (lineNumber == LINE_NUMBER_UNKNOWN \|\| (sourceMapCapable && column == -1)) {
	// Safari will send line numbers, with col == -1, we need to use symbolMap in this case
	lineNumber = Integer.parseInt(parts[4]);
	}

	fragmentId = Integer.parseInt(parts[5]);
	}
	}

	// anonymous function, try to use <fragmentNum>.js:line to determine fragment id
	if (fragmentId == -1 && steFilename != null) {
	// fragment identifier encoded in filename
	Matcher matcher = fragmentIdPattern.matcher(steFilename);
	if (matcher.matches()) {
	String fragment = matcher.group(1);
	try {
	fragmentId = Integer.parseInt(fragment);
	} catch (Exception e) {
	}
	} else if (steFilename.contains(strongName)) {
	// else it's <strongName>.cache.js which is the 0th fragment
	fragmentId = 0;
	}
	}


	int jsLineNumber = ste.getLineNumber();

	// try to refine location via sourcemap
	if (sourceMapCapable && fragmentId != -1 && column != -1) {
	SourceMapping sourceMapping = loadSourceMap(strongName, fragmentId);
	if (sourceMapping != null && ste.getLineNumber() > -1) {
	Mapping.OriginalMapping mappingForLine = sourceMapping
	.getMappingForLine(jsLineNumber, column);
	if (mappingForLine != null) {

	if (declaringClass == null \|\| declaringClass.equals(ste.getClassName())) {
	declaringClass = mappingForLine.getOriginalFile();
	methodName = mappingForLine.getIdentifier();
	}
	filename = mappingForLine.getOriginalFile();
	lineNumber = mappingForLine.getLineNumber();
	}
	}
	}

	if (declaringClass != null) {
	return new StackTraceElement(declaringClass, methodName, filename, lineNumber);
	}

	// If anything goes wrong, just return the unobfuscated element
	return ste;
	}

	public void setSymbolMapsDirectory(String symbolMapsDirectory) {
	// permutations are unique, no need to clear the symbolMaps hash map
	this.symbolMapsDirectory = new File(symbolMapsDirectory);
	}

	protected InputStream getSourceMapInputStream(String permutationStrongName, int fragmentNumber)
	throws IOException {
	String filename = symbolMapsDirectory.getCanonicalPath()
	+ File.separatorChar + permutationStrongName + "_sourceMap" + fragmentNumber + ".json";
	return new FileInputStream(filename);
	}

	/**
	* Retrieves a new {@link InputStream} for the given permutation strong name. This implementation,
	* which subclasses may override, returns a {@link InputStream} for the <code>
	* <i>permutation-strong-name</i>.symbolMap</code> file in the <code>symbolMaps</code> directory.
	*
	* @param permutationStrongName the GWT permutation strong name
	* @return a new {@link InputStream}
	*/
	protected InputStream getSymbolMapInputStream(String permutationStrongName)
	throws IOException {
	String filename = symbolMapsDirectory.getCanonicalPath()
	+ File.separatorChar + permutationStrongName + ".symbolMap";
	return new FileInputStream(filename);
	}

	private Throwable deobfuscateThrowable(Throwable old, String strongName) {
	Throwable t = new Throwable(old.getMessage());
	if (old.getStackTrace() != null) {
	t.setStackTrace(deobfuscateStackTrace(old.getStackTrace(), strongName));
	} else {
	t.setStackTrace(new StackTraceElement[0]);
	}
	if (old.getCause() != null) {
	t.initCause(deobfuscateThrowable(old.getCause(), strongName));
	}
	return t;
	}

	private SourceMapping loadSourceMap(String permutationStrongName, int fragmentId) {
	SourceMapping toReturn = sourceMaps.get(permutationStrongName + fragmentId);
	if (toReturn == null) {
	try {
	String sourceMapString = loadStreamAsString(
	getSourceMapInputStream(permutationStrongName, fragmentId));
	toReturn = SourceMapConsumerFactory.parse(sourceMapString);
	sourceMaps.put(permutationStrongName + fragmentId, toReturn);
	} catch (Exception e) {
	}
	}
	return toReturn;
	}

	private String loadStreamAsString(InputStream stream) {
	return new Scanner(stream).useDelimiter("\\A").next();
	}

	private SymbolMap loadSymbolMap(
	String strongName) {
	SymbolMap toReturn = symbolMaps.get(strongName);
	if (toReturn != null) {
	return toReturn;
	}
	toReturn = new SymbolMap();
	String line;

	try {
	BufferedReader bin = new BufferedReader(
	new InputStreamReader(getSymbolMapInputStream(strongName)));
	try {
	while ((line = bin.readLine()) != null) {
	if (line.charAt(0) == '#') {
	continue;
	}
	int idx = line.indexOf(',');
	toReturn.put(new String(line.substring(0, idx)),
	line.substring(idx + 1));
	}
	} finally {
	bin.close();
	}
	} catch (IOException e) {
	// use empty symbol map to avoid repeated lookups
	toReturn = new SymbolMap();
	}

	symbolMaps.put(strongName, toReturn);
	return toReturn;
	}

	/**
	* Extracts the declaring class and method name from a JSNI ref, or null if the information cannot
	* be extracted.
	*
	* @param refString symbol map reference string
	* @return a string array contains the declaring class and method name, or null when the regex
	* match fails
	* @see com.google.gwt.dev.util.JsniRef
	*/
	private String[] parse(String refString) {
	Matcher matcher = JsniRefPattern.matcher(refString);
	if (!matcher.matches()) {
	return null;
	}
	String className = matcher.group(1);
	String memberName = matcher.group(2);
	String[] toReturn = new String[]{className, memberName};
	return toReturn;
	}
	}