Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.brooklyn.util.javalang; import java.io.PrintWriter; import java.io.StringWriter; import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import org.apache.brooklyn.util.text.Strings; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.annotations.Beta; import com.google.common.collect.ImmutableSet; /** * Utility class for cleaning up stacktraces. */ public class StackTraceSimplifier { private static final Logger log = LoggerFactory.getLogger(StackTraceSimplifier.class); /** comma-separated prefixes (not regexes) */ public static final String DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "org.apache.brooklyn.util.javalang.StackTraceSimplifier.blacklist"; /** @deprecated since 0.8.0 use {@link #DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME} */ @Deprecated public static final String LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "brooklyn.util.javalang.StackTraceSimplifier.blacklist"; private static final Collection<String> DEFAULT_BLACKLIST; static { ImmutableSet.Builder<String> blacklist = ImmutableSet.builder(); blacklist.addAll(Arrays.asList(System .getProperty(DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME, "java.," + "javax.," + "sun.," + "groovy.," + "org.codehaus.groovy.," + "gjdk.groovy.,") .split("(\\s|,)+"))); String legacyDefaults = System.getProperty(LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME); if (Strings.isNonBlank(legacyDefaults)) { log.warn("Detected ude of legacy system property " + LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME); blacklist.addAll(Arrays.asList(legacyDefaults.split("(\\s|,)+"))); } DEFAULT_BLACKLIST = blacklist.build(); } private static final StackTraceSimplifier DEFAULT_INSTACE = newInstance(); private final Collection<String> blacklist; protected StackTraceSimplifier() { this(true); } protected StackTraceSimplifier(boolean includeDefaultBlacklist, String... packages) { ImmutableSet.Builder<String> blacklistB = ImmutableSet.builder(); if (includeDefaultBlacklist) blacklistB.addAll(DEFAULT_BLACKLIST); blacklistB.add(packages); blacklist = blacklistB.build(); } public static StackTraceSimplifier newInstance() { return new StackTraceSimplifier(); } public static StackTraceSimplifier newInstance(String... additionalBlacklistPackagePrefixes) { return new StackTraceSimplifier(true, additionalBlacklistPackagePrefixes); } public static StackTraceSimplifier newInstanceExcludingOnly(String... blacklistPackagePrefixes) { return new StackTraceSimplifier(false, blacklistPackagePrefixes); } /** @return whether the given element is useful, that is, not in the blacklist */ public boolean isUseful(StackTraceElement el) { for (String s : blacklist) { if (el.getClassName().startsWith(s)) return false; ; // gets underscores in some contexts ? if (el.getClassName().replace('_', '.').startsWith(s)) return false; } return true; } /** @return new list containing just the {@link #isUseful(StackTraceElement)} stack trace elements */ public List<StackTraceElement> clean(Iterable<StackTraceElement> st) { List<StackTraceElement> result = new LinkedList<StackTraceElement>(); for (StackTraceElement element : st) { if (isUseful(element)) { result.add(element); } } return result; } /** @return new array containing just the {@link #isUseful(StackTraceElement)} stack trace elements */ public StackTraceElement[] clean(StackTraceElement[] st) { List<StackTraceElement> result = clean(Arrays.asList(st)); return result.toArray(new StackTraceElement[result.size()]); } /** @return first {@link #isUseful(StackTraceElement)} stack trace elements, or null */ public StackTraceElement firstUseful(StackTraceElement[] st) { return nthUseful(0, st); } /** @return (n+1)th {@link #isUseful(StackTraceElement)} stack trace elements (ie 0 is {@link #firstUseful(StackTraceElement[])}), or null */ public StackTraceElement nthUseful(int n, StackTraceElement[] st) { for (StackTraceElement element : st) { if (isUseful(element)) { if (n == 0) return element; n--; } } return null; } /** {@link #clean(StackTraceElement[])} the given throwable instance, returning the same instance for convenience */ public <T extends Throwable> T cleaned(T t) { t.setStackTrace(clean(t.getStackTrace())); return t; } // ---- statics /** static convenience for {@link #isUseful(StackTraceElement)} */ public static boolean isStackTraceElementUseful(StackTraceElement el) { return DEFAULT_INSTACE.isUseful(el); } /** static convenience for {@link #clean(Iterable)} */ public static List<StackTraceElement> cleanStackTrace(Iterable<StackTraceElement> st) { return DEFAULT_INSTACE.clean(st); } /** static convenience for {@link #clean(StackTraceElement[])} */ public static StackTraceElement[] cleanStackTrace(StackTraceElement[] st) { return DEFAULT_INSTACE.clean(st); } /** static convenience for {@link #cleaned(Throwable)} */ public static <T extends Throwable> T cleanedStackTrace(T t) { return DEFAULT_INSTACE.cleaned(t); } public static String toString(Throwable t) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); t.printStackTrace(pw); return sw.getBuffer().toString(); } /** returns the number of times the calling method occurs elsewhere in the stack trace; * 0 if no recursion, 1 if it has cycled three times, etc. */ @Beta // useful to track down things like https://github.com/apache/incubator-brooklyn/pull/489 public static int getRecursiveCallCount() { StackTraceElement[] t = cleanStackTrace(new Throwable().getStackTrace()); Iterator<StackTraceElement> ti = Arrays.asList(t).iterator(); ti.next(); if (!ti.hasNext()) return 0; // t0 is the caller StackTraceElement t0 = ti.next(); String l0 = t0.getClassName() + "." + t0.getMethodName() + "(" + t0.getFileName() + ")"; int count = 0; while (ti.hasNext()) { StackTraceElement ta = ti.next(); String li = ta.getClassName() + "." + ta.getMethodName() + "(" + ta.getFileName() + ")"; // if we have something in a different method, then something back in the method // from which the recursive check came, then return true if (li.equals(l0)) count++; } return count; } }