repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/DefaultConversionService.java | core/src/main/java/com/taobao/arthas/core/env/convert/DefaultConversionService.java | package com.taobao.arthas.core.env.convert;
import java.lang.reflect.Array;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.concurrent.ConcurrentHashMap;
public class DefaultConversionService implements ConfigurableConversionService {
private static ConcurrentHashMap<ConvertiblePair, Converter> converters = new ConcurrentHashMap<ConvertiblePair, Converter>();
public DefaultConversionService() {
addDefaultConverter();
}
private void addDefaultConverter() {
converters.put(new ConvertiblePair(String.class, Integer.class), new StringToIntegerConverter());
converters.put(new ConvertiblePair(String.class, Long.class), new StringToLongConverter());
converters.put(new ConvertiblePair(String.class, Boolean.class), new StringToBooleanConverter());
converters.put(new ConvertiblePair(String.class, InetAddress.class), new StringToInetAddressConverter());
converters.put(new ConvertiblePair(String.class, Enum.class), new StringToEnumConverter());
converters.put(new ConvertiblePair(String.class, Arrays.class), new StringToArrayConverter(this));
}
@Override
public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
if (sourceType == targetType) {
return true;
}
if (targetType.isPrimitive()) {
targetType = objectiveClass(targetType);
}
if (converters.containsKey(new ConvertiblePair(sourceType, targetType))) {
return true;
}
if (targetType.isEnum()) {
if (converters.containsKey(new ConvertiblePair(sourceType, Enum.class))) {
return true;
}
}
if (targetType.isArray()) {
return true;
}
return false;
}
@Override
public <T> T convert(Object source, Class<T> targetType) {
if (targetType.isPrimitive()) {
targetType = (Class<T>) objectiveClass(targetType);
}
Converter converter = converters.get(new ConvertiblePair(source.getClass(), targetType));
if (converter == null && targetType.isArray()) {
converter = converters.get(new ConvertiblePair(source.getClass(), Arrays.class));
}
if (converter == null && targetType.isEnum()) {
converter = converters.get(new ConvertiblePair(source.getClass(), Enum.class));
}
if (converter != null) {
return (T) converter.convert(source, targetType);
}
return (T) source;
}
/**
* Get an array class of the given class.
*
* @param klass to get an array class of
* @param <C> the targeted class
* @return an array class of the given class
*/
public static <C> Class<C[]> arrayClass(Class<C> klass) {
return (Class<C[]>) Array.newInstance(klass, 0).getClass();
}
/**
* Get the class that extends {@link Object} that represent the given class.
*
* @param klass to get the object class of
* @return the class that extends Object class and represent the given class
*/
public static Class<?> objectiveClass(Class<?> klass) {
Class<?> component = klass.getComponentType();
if (component != null) {
if (component.isPrimitive() || component.isArray())
return arrayClass(objectiveClass(component));
} else if (klass.isPrimitive()) {
if (klass == char.class)
return Character.class;
if (klass == int.class)
return Integer.class;
if (klass == boolean.class)
return Boolean.class;
if (klass == byte.class)
return Byte.class;
if (klass == double.class)
return Double.class;
if (klass == float.class)
return Float.class;
if (klass == long.class)
return Long.class;
if (klass == short.class)
return Short.class;
}
return klass;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/Converter.java | core/src/main/java/com/taobao/arthas/core/env/convert/Converter.java | /*
* Copyright 2002-2015 the original author or authors.
*
* 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.taobao.arthas.core.env.convert;
/**
* A converter converts a source object of type S to a target of type T.
* Implementations of this interface are thread-safe and can be shared.
*
* <p>Implementations may additionally implement {@link ConditionalConverter}.
*
* @author Keith Donald
* @since 3.0
* @param <S> The source type
* @param <T> The target type
*/
public interface Converter<S, T> {
/**
* Convert the source of type S to target type T.
* @param source the source object to convert, which must be an instance of S (never {@code null})
* @return the converted object, which must be an instance of T (potentially {@code null})
* @throws IllegalArgumentException if the source could not be converted to the desired target type
*/
T convert(S source, Class<T> targetType);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/ObjectToStringConverter.java | core/src/main/java/com/taobao/arthas/core/env/convert/ObjectToStringConverter.java | /*
* Copyright 2002-2014 the original author or authors.
*
* 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.taobao.arthas.core.env.convert;
/**
* Simply calls {@link Object#toString()} to convert a source Object to a String.
*
* @author Keith Donald
* @since 3.0
*/
final class ObjectToStringConverter implements Converter<Object, String> {
public String convert(Object source, Class<String> targetType) {
return source.toString();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/ConfigurableConversionService.java | core/src/main/java/com/taobao/arthas/core/env/convert/ConfigurableConversionService.java | /*
* Copyright 2002-2011 the original author or authors.
*
* 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
*
* https://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.taobao.arthas.core.env.convert;
import com.taobao.arthas.core.env.ConversionService;
/**
* Configuration interface to be implemented by most if not all
* {@link ConversionService} types. Consolidates the read-only operations
* exposed by {@link ConversionService} and the mutating operations of
* {@link ConverterRegistry} to allow for convenient ad-hoc addition and removal
* of {@link org.springframework.core.convert.converter.Converter Converters}
* through. The latter is particularly useful when working against a
* {@link org.springframework.core.env.ConfigurableEnvironment
* ConfigurableEnvironment} instance in application context bootstrapping code.
*
* @author Chris Beams
* @since 3.1
* @see com.taobao.arthas.core.env.springframework.core.env.ConfigurablePropertyResolver#getConversionService()
* @see org.springframework.core.env.ConfigurableEnvironment
* @see org.springframework.context.ConfigurableApplicationContext#getEnvironment()
*/
public interface ConfigurableConversionService extends ConversionService {
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/StringToBooleanConverter.java | core/src/main/java/com/taobao/arthas/core/env/convert/StringToBooleanConverter.java | /*
* Copyright 2002-2011 the original author or authors.
*
* 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.taobao.arthas.core.env.convert;
import java.util.HashSet;
import java.util.Set;
/**
* Converts String to a Boolean.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 3.0
*/
final class StringToBooleanConverter implements Converter<String, Boolean> {
private static final Set<String> trueValues = new HashSet<String>(4);
private static final Set<String> falseValues = new HashSet<String>(4);
static {
trueValues.add("true");
trueValues.add("on");
trueValues.add("yes");
trueValues.add("1");
falseValues.add("false");
falseValues.add("off");
falseValues.add("no");
falseValues.add("0");
}
public Boolean convert(String source, Class<Boolean> targetType) {
String value = source.trim();
if ("".equals(value)) {
return null;
}
value = value.toLowerCase();
if (trueValues.contains(value)) {
return Boolean.TRUE;
}
else if (falseValues.contains(value)) {
return Boolean.FALSE;
}
else {
throw new IllegalArgumentException("Invalid boolean value '" + source + "'");
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/StringToLongConverter.java | core/src/main/java/com/taobao/arthas/core/env/convert/StringToLongConverter.java |
package com.taobao.arthas.core.env.convert;
final class StringToLongConverter implements Converter<String, Long> {
@Override
public Long convert(String source, Class<Long> targetType) {
return Long.parseLong(source);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/env/convert/StringToEnumConverter.java | core/src/main/java/com/taobao/arthas/core/env/convert/StringToEnumConverter.java |
package com.taobao.arthas.core.env.convert;
@SuppressWarnings("rawtypes")
final class StringToEnumConverter<T extends Enum> implements Converter<String, T> {
@SuppressWarnings("unchecked")
@Override
public T convert(String source, Class<T> targetType) {
return (T) Enum.valueOf(targetType, source);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/InvokeTraceable.java | core/src/main/java/com/taobao/arthas/core/advisor/InvokeTraceable.java | package com.taobao.arthas.core.advisor;
/**
* 方法调用跟踪<br/>
* 当一个方法内部调用另外一个方法时，会触发此跟踪方法
* Created by vlinux on 15/5/27.
*/
public interface InvokeTraceable {
/**
* 调用之前跟踪
*
* @param tracingClassName 调用类名
* @param tracingMethodName 调用方法名
* @param tracingMethodDesc 调用方法描述
* @param tracingLineNumber 执行调用行数
* @throws Throwable 通知过程出错
*/
void invokeBeforeTracing(
ClassLoader classLoader,
String tracingClassName,
String tracingMethodName,
String tracingMethodDesc,
int tracingLineNumber) throws Throwable;
/**
* 抛异常后跟踪
*
* @param tracingClassName 调用类名
* @param tracingMethodName 调用方法名
* @param tracingMethodDesc 调用方法描述
* @param tracingLineNumber 执行调用行数
* @throws Throwable 通知过程出错
*/
void invokeThrowTracing(
ClassLoader classLoader,
String tracingClassName,
String tracingMethodName,
String tracingMethodDesc,
int tracingLineNumber) throws Throwable;
/**
* 调用之后跟踪
*
* @param tracingClassName 调用类名
* @param tracingMethodName 调用方法名
* @param tracingMethodDesc 调用方法描述
* @param tracingLineNumber 执行调用行数
* @throws Throwable 通知过程出错
*/
void invokeAfterTracing(
ClassLoader classLoader,
String tracingClassName,
String tracingMethodName,
String tracingMethodDesc,
int tracingLineNumber) throws Throwable;
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/AccessPoint.java | core/src/main/java/com/taobao/arthas/core/advisor/AccessPoint.java | package com.taobao.arthas.core.advisor;
public enum AccessPoint {
ACCESS_BEFORE(1, "AtEnter"), ACCESS_AFTER_RETUNING(1 << 1, "AtExit"), ACCESS_AFTER_THROWING(1 << 2, "AtExceptionExit");
private int value;
private String key;
public int getValue() {
return value;
}
public String getKey() {
return key;
}
AccessPoint(int value, String key) {
this.value = value;
this.key = key;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/AdviceListenerAdapter.java | core/src/main/java/com/taobao/arthas/core/advisor/AdviceListenerAdapter.java | package com.taobao.arthas.core.advisor;
import java.util.concurrent.atomic.AtomicLong;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.system.ProcessAware;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.StringUtils;
/**
*
* @author hengyunabc 2020-05-20
*
*/
public abstract class AdviceListenerAdapter implements AdviceListener, ProcessAware {
private static final AtomicLong ID_GENERATOR = new AtomicLong(0);
private Process process;
private long id = ID_GENERATOR.addAndGet(1);
private boolean verbose;
@Override
public long id() {
return id;
}
@Override
public void create() {
// default no-op
}
@Override
public void destroy() {
// default no-op
}
public Process getProcess() {
return process;
}
public void setProcess(Process process) {
this.process = process;
}
@Override
final public void before(Class<?> clazz, String methodName, String methodDesc, Object target, Object[] args)
throws Throwable {
before(clazz.getClassLoader(), clazz, new ArthasMethod(clazz, methodName, methodDesc), target, args);
}
@Override
final public void afterReturning(Class<?> clazz, String methodName, String methodDesc, Object target, Object[] args,
Object returnObject) throws Throwable {
afterReturning(clazz.getClassLoader(), clazz, new ArthasMethod(clazz, methodName, methodDesc), target, args,
returnObject);
}
@Override
final public void afterThrowing(Class<?> clazz, String methodName, String methodDesc, Object target, Object[] args,
Throwable throwable) throws Throwable {
afterThrowing(clazz.getClassLoader(), clazz, new ArthasMethod(clazz, methodName, methodDesc), target, args,
throwable);
}
/**
* 前置通知
*
* @param loader 类加载器
* @param clazz 类
* @param method 方法
* @param target 目标类实例 若目标为静态方法,则为null
* @param args 参数列表
* @throws Throwable 通知过程出错
*/
public abstract void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable;
/**
* 返回通知
*
* @param loader 类加载器
* @param clazz 类
* @param method 方法
* @param target 目标类实例 若目标为静态方法,则为null
* @param args 参数列表
* @param returnObject 返回结果 若为无返回值方法(void),则为null
* @throws Throwable 通知过程出错
*/
public abstract void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target,
Object[] args, Object returnObject) throws Throwable;
/**
* 异常通知
*
* @param loader 类加载器
* @param clazz 类
* @param method 方法
* @param target 目标类实例 若目标为静态方法,则为null
* @param args 参数列表
* @param throwable 目标异常
* @throws Throwable 通知过程出错
*/
public abstract void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target,
Object[] args, Throwable throwable) throws Throwable;
/**
* 判断条件是否满足，满足的情况下需要输出结果
*
* @param conditionExpress 条件表达式
* @param advice 当前的advice对象
* @param cost 本次执行的耗时
* @return true 如果条件表达式满足
*/
protected boolean isConditionMet(String conditionExpress, Advice advice, double cost) throws ExpressException {
return StringUtils.isEmpty(conditionExpress)
|| ExpressFactory.threadLocalExpress(advice).bind(Constants.COST_VARIABLE, cost).is(conditionExpress);
}
protected Object getExpressionResult(String express, Advice advice, double cost) throws ExpressException {
return ExpressFactory.threadLocalExpress(advice).bind(Constants.COST_VARIABLE, cost).get(express);
}
/**
* 是否超过了上限，超过之后，停止输出
*
* @param limit 命令执行上限
* @param currentTimes 当前执行次数
* @return true 如果超过或者达到了上限
*/
protected boolean isLimitExceeded(int limit, int currentTimes) {
return currentTimes >= limit;
}
/**
* 超过次数上限，则不再输出，命令终止
*
* @param process the process to be aborted
* @param limit the limit to be printed
*/
protected void abortProcess(CommandProcess process, int limit) {
process.write("Command execution times exceed limit: " + limit
+ ", so command will exit. You can set it with -n option.\n");
process.end();
}
public boolean isVerbose() {
return verbose;
}
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/Advice.java | core/src/main/java/com/taobao/arthas/core/advisor/Advice.java | package com.taobao.arthas.core.advisor;
/**
* 通知点 Created by vlinux on 15/5/20.
*/
public class Advice {
private final ClassLoader loader;
private final Class<?> clazz;
private final ArthasMethod method;
private final Object target;
private final Object[] params;
private final Object returnObj;
private final Throwable throwExp;
private final boolean isBefore;
private final boolean isThrow;
private final boolean isReturn;
public boolean isBefore() {
return isBefore;
}
public boolean isAfterReturning() {
return isReturn;
}
public boolean isAfterThrowing() {
return isThrow;
}
public ClassLoader getLoader() {
return loader;
}
public Object getTarget() {
return target;
}
public Object[] getParams() {
return params;
}
public Object getReturnObj() {
return returnObj;
}
public Throwable getThrowExp() {
return throwExp;
}
public Class<?> getClazz() {
return clazz;
}
public ArthasMethod getMethod() {
return method;
}
/**
* for finish
*
* @param loader 类加载器
* @param clazz 类
* @param method 方法
* @param target 目标类
* @param params 调用参数
* @param returnObj 返回值
* @param throwExp 抛出异常
* @param access 进入场景
*/
private Advice(
ClassLoader loader,
Class<?> clazz,
ArthasMethod method,
Object target,
Object[] params,
Object returnObj,
Throwable throwExp,
int access) {
this.loader = loader;
this.clazz = clazz;
this.method = method;
this.target = target;
this.params = params;
this.returnObj = returnObj;
this.throwExp = throwExp;
isBefore = (access & AccessPoint.ACCESS_BEFORE.getValue()) == AccessPoint.ACCESS_BEFORE.getValue();
isThrow = (access & AccessPoint.ACCESS_AFTER_THROWING.getValue()) == AccessPoint.ACCESS_AFTER_THROWING.getValue();
isReturn = (access & AccessPoint.ACCESS_AFTER_RETUNING.getValue()) == AccessPoint.ACCESS_AFTER_RETUNING.getValue();
}
public static Advice newForBefore(ClassLoader loader,
Class<?> clazz,
ArthasMethod method,
Object target,
Object[] params) {
return new Advice(
loader,
clazz,
method,
target,
params,
null, //returnObj
null, //throwExp
AccessPoint.ACCESS_BEFORE.getValue()
);
}
public static Advice newForAfterReturning(ClassLoader loader,
Class<?> clazz,
ArthasMethod method,
Object target,
Object[] params,
Object returnObj) {
return new Advice(
loader,
clazz,
method,
target,
params,
returnObj,
null, //throwExp
AccessPoint.ACCESS_AFTER_RETUNING.getValue()
);
}
public static Advice newForAfterThrowing(ClassLoader loader,
Class<?> clazz,
ArthasMethod method,
Object target,
Object[] params,
Throwable throwExp) {
return new Advice(
loader,
clazz,
method,
target,
params,
null, //returnObj
throwExp,
AccessPoint.ACCESS_AFTER_THROWING.getValue()
);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/ArthasMethod.java | core/src/main/java/com/taobao/arthas/core/advisor/ArthasMethod.java | package com.taobao.arthas.core.advisor;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import com.alibaba.deps.org.objectweb.asm.Type;
import com.taobao.arthas.core.util.StringUtils;
/**
*
* 主要用于 tt 命令重放使用
*
* @author vlinux on 15/5/24
* @author hengyunabc 2020-05-20
*
*/
public class ArthasMethod {
private final Class<?> clazz;
private final String methodName;
private final String methodDesc;
private Constructor<?> constructor;
private Method method;
private void initMethod() {
if (constructor != null || method != null) {
return;
}
try {
ClassLoader loader = this.clazz.getClassLoader();
final Type asmType = Type.getMethodType(methodDesc);
// to arg types
final Class<?>[] argsClasses = new Class<?>[asmType.getArgumentTypes().length];
for (int index = 0; index < argsClasses.length; index++) {
// asm class descriptor to jvm class
final Class<?> argumentClass;
final Type argumentAsmType = asmType.getArgumentTypes()[index];
switch (argumentAsmType.getSort()) {
case Type.BOOLEAN: {
argumentClass = boolean.class;
break;
}
case Type.CHAR: {
argumentClass = char.class;
break;
}
case Type.BYTE: {
argumentClass = byte.class;
break;
}
case Type.SHORT: {
argumentClass = short.class;
break;
}
case Type.INT: {
argumentClass = int.class;
break;
}
case Type.FLOAT: {
argumentClass = float.class;
break;
}
case Type.LONG: {
argumentClass = long.class;
break;
}
case Type.DOUBLE: {
argumentClass = double.class;
break;
}
case Type.ARRAY: {
argumentClass = toClass(loader, argumentAsmType.getInternalName());
break;
}
case Type.VOID: {
argumentClass = void.class;
break;
}
case Type.OBJECT:
case Type.METHOD:
default: {
argumentClass = toClass(loader, argumentAsmType.getClassName());
break;
}
}
argsClasses[index] = argumentClass;
}
if ("<init>".equals(this.methodName)) {
this.constructor = clazz.getDeclaredConstructor(argsClasses);
} else {
this.method = clazz.getDeclaredMethod(methodName, argsClasses);
}
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
private Class<?> toClass(ClassLoader loader, String className) throws ClassNotFoundException {
return Class.forName(StringUtils.normalizeClassName(className), true, toClassLoader(loader));
}
private ClassLoader toClassLoader(ClassLoader loader) {
return null != loader ? loader : ArthasMethod.class.getClassLoader();
}
/**
* 获取方法名称
*
* @return 返回方法名称
*/
public String getName() {
return this.methodName;
}
@Override
public String toString() {
initMethod();
if (constructor != null) {
return constructor.toString();
} else if (method != null) {
return method.toString();
}
return "ERROR_METHOD";
}
public boolean isAccessible() {
initMethod();
if (this.method != null) {
return method.isAccessible();
} else if (this.constructor != null) {
return constructor.isAccessible();
}
return false;
}
public void setAccessible(boolean accessFlag) {
initMethod();
if (constructor != null) {
constructor.setAccessible(accessFlag);
} else if (method != null) {
method.setAccessible(accessFlag);
}
}
public Object invoke(Object target, Object... args)
throws IllegalAccessException, InvocationTargetException, InstantiationException {
initMethod();
if (method != null) {
return method.invoke(target, args);
} else if (this.constructor != null) {
return constructor.newInstance(args);
}
return null;
}
public ArthasMethod(Class<?> clazz, String methodName, String methodDesc) {
this.clazz = clazz;
this.methodName = methodName;
this.methodDesc = methodDesc;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/Enhancer.java | core/src/main/java/com/taobao/arthas/core/advisor/Enhancer.java | package com.taobao.arthas.core.advisor;
import static com.taobao.arthas.core.util.ArthasCheckUtils.isEquals;
import static java.lang.System.arraycopy;
import java.arthas.SpyAPI;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.Method;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.alibaba.deps.org.objectweb.asm.Opcodes;
import com.alibaba.deps.org.objectweb.asm.Type;
import com.alibaba.deps.org.objectweb.asm.tree.AbstractInsnNode;
import com.alibaba.deps.org.objectweb.asm.tree.ClassNode;
import com.alibaba.deps.org.objectweb.asm.tree.MethodInsnNode;
import com.alibaba.deps.org.objectweb.asm.tree.MethodNode;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.bytekit.asm.MethodProcessor;
import com.alibaba.bytekit.asm.interceptor.InterceptorProcessor;
import com.alibaba.bytekit.asm.interceptor.parser.DefaultInterceptorClassParser;
import com.alibaba.bytekit.asm.location.Location;
import com.alibaba.bytekit.asm.location.LocationType;
import com.alibaba.bytekit.asm.location.MethodInsnNodeWare;
import com.alibaba.bytekit.asm.location.filter.GroupLocationFilter;
import com.alibaba.bytekit.asm.location.filter.InvokeCheckLocationFilter;
import com.alibaba.bytekit.asm.location.filter.InvokeContainLocationFilter;
import com.alibaba.bytekit.asm.location.filter.LocationFilter;
import com.alibaba.bytekit.utils.AsmOpUtils;
import com.alibaba.bytekit.utils.AsmUtils;
import com.taobao.arthas.common.Pair;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyInterceptor1;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyInterceptor2;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyInterceptor3;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceExcludeJDKInterceptor1;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceExcludeJDKInterceptor2;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceExcludeJDKInterceptor3;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceInterceptor1;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceInterceptor2;
import com.taobao.arthas.core.advisor.SpyInterceptors.SpyTraceInterceptor3;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.util.ArthasCheckUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.FileUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
/**
* 对类进行通知增强 Created by vlinux on 15/5/17.
* @author hengyunabc
*/
public class Enhancer implements ClassFileTransformer {
private static final Logger logger = LoggerFactory.getLogger(Enhancer.class);
private final AdviceListener listener;
private final boolean isTracing;
private final boolean skipJDKTrace;
private final Matcher classNameMatcher;
private final Matcher classNameExcludeMatcher;
private final Matcher methodNameMatcher;
private final EnhancerAffect affect;
private Set<Class<?>> matchingClasses = null;
private boolean isLazy = false;
private static final ClassLoader selfClassLoader = Enhancer.class.getClassLoader();
// 被增强的类的缓存
private final static Map<Class<?>/* Class */, Object> classBytesCache = new WeakHashMap<Class<?>, Object>();
private static SpyImpl spyImpl = new SpyImpl();
static {
SpyAPI.setSpy(spyImpl);
}
/**
* @param adviceId 通知编号
* @param isTracing 可跟踪方法调用
* @param skipJDKTrace 是否忽略对JDK内部方法的跟踪
* @param matchingClasses 匹配中的类
* @param methodNameMatcher 方法名匹配
* @param affect 影响统计
*/
public Enhancer(AdviceListener listener, boolean isTracing, boolean skipJDKTrace, Matcher classNameMatcher,
Matcher classNameExcludeMatcher,
Matcher methodNameMatcher) {
this(listener, isTracing, skipJDKTrace, classNameMatcher, classNameExcludeMatcher, methodNameMatcher, false);
}
/**
* @param adviceId 通知编号
* @param isTracing 可跟踪方法调用
* @param skipJDKTrace 是否忽略对JDK内部方法的跟踪
* @param matchingClasses 匹配中的类
* @param methodNameMatcher 方法名匹配
* @param affect 影响统计
* @param isLazy 是否懒加载模式
*/
public Enhancer(AdviceListener listener, boolean isTracing, boolean skipJDKTrace, Matcher classNameMatcher,
Matcher classNameExcludeMatcher,
Matcher methodNameMatcher, boolean isLazy) {
this.listener = listener;
this.isTracing = isTracing;
this.skipJDKTrace = skipJDKTrace;
this.classNameMatcher = classNameMatcher;
this.classNameExcludeMatcher = classNameExcludeMatcher;
this.methodNameMatcher = methodNameMatcher;
this.affect = new EnhancerAffect();
affect.setListenerId(listener.id());
this.isLazy = isLazy;
}
@Override
public byte[] transform(final ClassLoader inClassLoader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
try {
// 检查classloader能否加载到 SpyAPI，如果不能，则放弃增强
try {
if (inClassLoader != null) {
inClassLoader.loadClass(SpyAPI.class.getName());
}
} catch (Throwable e) {
logger.error("the classloader can not load SpyAPI, ignore it. classloader: {}, className: {}",
inClassLoader.getClass().getName(), className, e);
return null;
}
// 这里要再次过滤一次，为啥？因为在transform的过程中，有可能还会再诞生新的类
// 所以需要将之前需要转换的类集合传递下来，再次进行判断
if (matchingClasses != null && !matchingClasses.contains(classBeingRedefined)) {
// 懒加载模式：当类首次加载时（classBeingRedefined == null），检查类名是否匹配
if (isLazy && classBeingRedefined == null && className != null) {
// 将 className 从 internal name 转换为 binary name
String classNameDot = className.replace('/', '.');
if (!classNameMatcher.matching(classNameDot)) {
return null;
}
// 检查是否被排除
if (classNameExcludeMatcher != null && classNameExcludeMatcher.matching(classNameDot)) {
return null;
}
// 检查是否是 arthas 自身的类
if (inClassLoader != null && isEquals(inClassLoader, selfClassLoader)) {
return null;
}
// 检查是否是 unsafe 类
if (!GlobalOptions.isUnsafe && inClassLoader == null) {
return null;
}
logger.info("Lazy mode: enhancing newly loaded class: {}", classNameDot);
} else {
return null;
}
}
//keep origin class reader for bytecode optimizations, avoiding JVM metaspace OOM.
ClassNode classNode = new ClassNode(Opcodes.ASM9);
ClassReader classReader = AsmUtils.toClassNode(classfileBuffer, classNode);
// remove JSR https://github.com/alibaba/arthas/issues/1304
classNode = AsmUtils.removeJSRInstructions(classNode);
// 生成增强字节码
DefaultInterceptorClassParser defaultInterceptorClassParser = new DefaultInterceptorClassParser();
final List<InterceptorProcessor> interceptorProcessors = new ArrayList<InterceptorProcessor>();
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor3.class));
if (this.isTracing) {
if (!this.skipJDKTrace) {
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor3.class));
} else {
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor3.class));
}
}
List<MethodNode> matchedMethods = new ArrayList<MethodNode>();
for (MethodNode methodNode : classNode.methods) {
if (!isIgnore(methodNode, methodNameMatcher)) {
matchedMethods.add(methodNode);
}
}
// https://github.com/alibaba/arthas/issues/1690
if (AsmUtils.isEnhancerByCGLIB(className)) {
for (MethodNode methodNode : matchedMethods) {
if (AsmUtils.isConstructor(methodNode)) {
AsmUtils.fixConstructorExceptionTable(methodNode);
}
}
}
// 用于检查是否已插入了 spy函数，如果已有则不重复处理
GroupLocationFilter groupLocationFilter = new GroupLocationFilter();
LocationFilter enterFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class), "atEnter",
LocationType.ENTER);
LocationFilter existFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class), "atExit",
LocationType.EXIT);
LocationFilter exceptionFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class),
"atExceptionExit", LocationType.EXCEPTION_EXIT);
groupLocationFilter.addFilter(enterFilter);
groupLocationFilter.addFilter(existFilter);
groupLocationFilter.addFilter(exceptionFilter);
LocationFilter invokeBeforeFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atBeforeInvoke", LocationType.INVOKE);
LocationFilter invokeAfterFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atInvokeException", LocationType.INVOKE_COMPLETED);
LocationFilter invokeExceptionFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atInvokeException", LocationType.INVOKE_EXCEPTION_EXIT);
groupLocationFilter.addFilter(invokeBeforeFilter);
groupLocationFilter.addFilter(invokeAfterFilter);
groupLocationFilter.addFilter(invokeExceptionFilter);
for (MethodNode methodNode : matchedMethods) {
if (AsmUtils.isNative(methodNode)) {
logger.info("ignore native method: {}",
AsmUtils.methodDeclaration(Type.getObjectType(classNode.name), methodNode));
continue;
}
// 先查找是否有 atBeforeInvoke 函数，如果有，则说明已经有trace了，则直接不再尝试增强，直接插入 listener
if(AsmUtils.containsMethodInsnNode(methodNode, Type.getInternalName(SpyAPI.class), "atBeforeInvoke")) {
for (AbstractInsnNode insnNode = methodNode.instructions.getFirst(); insnNode != null; insnNode = insnNode
.getNext()) {
if (insnNode instanceof MethodInsnNode) {
final MethodInsnNode methodInsnNode = (MethodInsnNode) insnNode;
if(this.skipJDKTrace) {
if(methodInsnNode.owner.startsWith("java/")) {
continue;
}
}
// 原始类型的box类型相关的都跳过
if(AsmOpUtils.isBoxType(Type.getObjectType(methodInsnNode.owner))) {
continue;
}
AdviceListenerManager.registerTraceAdviceListener(inClassLoader, className,
methodInsnNode.owner, methodInsnNode.name, methodInsnNode.desc, listener);
}
}
}else {
MethodProcessor methodProcessor = new MethodProcessor(classNode, methodNode, groupLocationFilter);
for (InterceptorProcessor interceptor : interceptorProcessors) {
try {
List<Location> locations = interceptor.process(methodProcessor);
for (Location location : locations) {
if (location instanceof MethodInsnNodeWare) {
MethodInsnNodeWare methodInsnNodeWare = (MethodInsnNodeWare) location;
MethodInsnNode methodInsnNode = methodInsnNodeWare.methodInsnNode();
AdviceListenerManager.registerTraceAdviceListener(inClassLoader, className,
methodInsnNode.owner, methodInsnNode.name, methodInsnNode.desc, listener);
}
}
} catch (Throwable e) {
logger.error("enhancer error, class: {}, method: {}, interceptor: {}", classNode.name, methodNode.name, interceptor.getClass().getName(), e);
}
}
}
// enter/exist 总是要插入 listener
AdviceListenerManager.registerAdviceListener(inClassLoader, className, methodNode.name, methodNode.desc,
listener);
affect.addMethodAndCount(inClassLoader, className, methodNode.name, methodNode.desc);
}
// https://github.com/alibaba/arthas/issues/1223 , V1_5 的major version是49
if (AsmUtils.getMajorVersion(classNode.version) < 49) {
classNode.version = AsmUtils.setMajorVersion(classNode.version, 49);
}
byte[] enhanceClassByteArray = AsmUtils.toBytes(classNode, inClassLoader, classReader);
// 增强成功，记录类
classBytesCache.put(classBeingRedefined, new Object());
// dump the class
dumpClassIfNecessary(className, enhanceClassByteArray, affect);
// 成功计数
affect.cCnt(1);
return enhanceClassByteArray;
} catch (Throwable t) {
logger.warn("transform loader[{}]:class[{}] failed.", inClassLoader, className, t);
affect.setThrowable(t);
}
return null;
}
/**
* 是否抽象属性
*/
private boolean isAbstract(int access) {
return (Opcodes.ACC_ABSTRACT & access) == Opcodes.ACC_ABSTRACT;
}
/**
* 是否需要忽略
*/
private boolean isIgnore(MethodNode methodNode, Matcher methodNameMatcher) {
return null == methodNode || isAbstract(methodNode.access) || !methodNameMatcher.matching(methodNode.name)
|| ArthasCheckUtils.isEquals(methodNode.name, "<clinit>");
}
/**
* dump class to file
*/
private static void dumpClassIfNecessary(String className, byte[] data, EnhancerAffect affect) {
if (!GlobalOptions.isDump) {
return;
}
final File dumpClassFile = new File("./arthas-class-dump/" + className + ".class");
final File classPath = new File(dumpClassFile.getParent());
// 创建类所在的包路径
if (!classPath.mkdirs() && !classPath.exists()) {
logger.warn("create dump classpath:{} failed.", classPath);
return;
}
// 将类字节码写入文件
try {
FileUtils.writeByteArrayToFile(dumpClassFile, data);
affect.addClassDumpFile(dumpClassFile);
if (GlobalOptions.verbose) {
logger.info("dump enhanced class: {}, path: {}", className, dumpClassFile);
}
} catch (IOException e) {
logger.warn("dump class:{} to file {} failed.", className, dumpClassFile, e);
}
}
/**
* 是否需要过滤的类
*
* @param classes 类集合
*/
private List<Pair<Class<?>, String>> filter(Set<Class<?>> classes) {
List<Pair<Class<?>, String>> filteredClasses = new ArrayList<Pair<Class<?>, String>>();
final Iterator<Class<?>> it = classes.iterator();
while (it.hasNext()) {
final Class<?> clazz = it.next();
boolean removeFlag = false;
if (null == clazz) {
removeFlag = true;
} else if (isSelf(clazz)) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, "class loaded by arthas itself"));
removeFlag = true;
} else if (isUnsafeClass(clazz)) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, "class loaded by Bootstrap Classloader, try to execute `options unsafe true`"));
removeFlag = true;
} else if (isExclude(clazz)) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, "class is excluded"));
removeFlag = true;
} else {
Pair<Boolean, String> unsupportedResult = isUnsupportedClass(clazz);
if (unsupportedResult.getFirst()) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, unsupportedResult.getSecond()));
removeFlag = true;
}
}
if (removeFlag) {
it.remove();
}
}
return filteredClasses;
}
private boolean isExclude(Class<?> clazz) {
if (this.classNameExcludeMatcher != null) {
return classNameExcludeMatcher.matching(clazz.getName());
}
return false;
}
/**
* 是否过滤Arthas加载的类
*/
private static boolean isSelf(Class<?> clazz) {
return null != clazz && isEquals(clazz.getClassLoader(), selfClassLoader);
}
/**
* 是否过滤unsafe类
*/
private static boolean isUnsafeClass(Class<?> clazz) {
return !GlobalOptions.isUnsafe && clazz.getClassLoader() == null;
}
/**
* 是否过滤目前暂不支持的类
*/
private static Pair<Boolean, String> isUnsupportedClass(Class<?> clazz) {
if (ClassUtils.isLambdaClass(clazz)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is lambda");
}
if (clazz.isInterface() && !GlobalOptions.isSupportDefaultMethod) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is interface");
}
if (clazz.equals(Integer.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Integer");
}
if (clazz.equals(Class.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Class");
}
if (clazz.equals(Method.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Method");
}
if (clazz.isArray()) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is array");
}
return new Pair<Boolean, String>(Boolean.FALSE, "");
}
/**
* 对象增强
*
* @param inst inst
* @param maxNumOfMatchedClass 匹配的class最大数量
* @return 增强影响范围
* @throws UnmodifiableClassException 增强失败
*/
public synchronized EnhancerAffect enhance(final Instrumentation inst, int maxNumOfMatchedClass) throws UnmodifiableClassException {
// 获取需要增强的类集合
this.matchingClasses = GlobalOptions.isDisableSubClass
? SearchUtils.searchClass(inst, classNameMatcher)
: SearchUtils.searchSubClass(inst, SearchUtils.searchClass(inst, classNameMatcher));
if (matchingClasses.size() > maxNumOfMatchedClass) {
affect.setOverLimitMsg("The number of matched classes is " +matchingClasses.size()+ ", greater than the limit value " + maxNumOfMatchedClass + ". Try to change the limit with option '-m <arg>'.");
return affect;
}
// 过滤掉无法被增强的类
List<Pair<Class<?>, String>> filtedList = filter(matchingClasses);
if (!filtedList.isEmpty()) {
for (Pair<Class<?>, String> filted : filtedList) {
logger.info("ignore class: {}, reason: {}", filted.getFirst().getName(), filted.getSecond());
}
}
logger.info("enhance matched classes: {}", matchingClasses);
affect.setTransformer(this);
try {
ArthasBootstrap.getInstance().getTransformerManager().addTransformer(this, isTracing);
// 懒加载模式：同时添加到懒加载 transformer 列表
// 这样才能在类首次加载时被增强
if (isLazy) {
ArthasBootstrap.getInstance().getTransformerManager().addLazyTransformer(this);
logger.info("Lazy mode enabled, transformer added to lazy transformer list");
}
// 批量增强
if (GlobalOptions.isBatchReTransform) {
final int size = matchingClasses.size();
final Class<?>[] classArray = new Class<?>[size];
arraycopy(matchingClasses.toArray(), 0, classArray, 0, size);
if (classArray.length > 0) {
inst.retransformClasses(classArray);
logger.info("Success to batch transform classes: " + Arrays.toString(classArray));
}
} else {
// for each 增强
for (Class<?> clazz : matchingClasses) {
try {
inst.retransformClasses(clazz);
logger.info("Success to transform class: " + clazz);
} catch (Throwable t) {
logger.warn("retransform {} failed.", clazz, t);
if (t instanceof UnmodifiableClassException) {
throw (UnmodifiableClassException) t;
} else if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new RuntimeException(t);
}
}
}
}
} catch (Throwable e) {
logger.error("Enhancer error, matchingClasses: {}", matchingClasses, e);
affect.setThrowable(e);
}
return affect;
}
/**
* 重置指定的Class
*
* @param inst inst
* @param classNameMatcher 类名匹配
* @return 增强影响范围
* @throws UnmodifiableClassException
*/
public static synchronized EnhancerAffect reset(final Instrumentation inst, final Matcher classNameMatcher)
throws UnmodifiableClassException {
final EnhancerAffect affect = new EnhancerAffect();
final Set<Class<?>> enhanceClassSet = new HashSet<Class<?>>();
for (Class<?> classInCache : classBytesCache.keySet()) {
if (classNameMatcher.matching(classInCache.getName())) {
enhanceClassSet.add(classInCache);
}
}
try {
enhance(inst, enhanceClassSet);
logger.info("Success to reset classes: " + enhanceClassSet);
} finally {
for (Class<?> resetClass : enhanceClassSet) {
classBytesCache.remove(resetClass);
affect.cCnt(1);
}
}
return affect;
}
// 批量增强
private static void enhance(Instrumentation inst, Set<Class<?>> classes)
throws UnmodifiableClassException {
int size = classes.size();
Class<?>[] classArray = new Class<?>[size];
arraycopy(classes.toArray(), 0, classArray, 0, size);
if (classArray.length > 0) {
inst.retransformClasses(classArray);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/SpyInterceptors.java | core/src/main/java/com/taobao/arthas/core/advisor/SpyInterceptors.java | package com.taobao.arthas.core.advisor;
import java.arthas.SpyAPI;
import com.alibaba.bytekit.asm.binding.Binding;
import com.alibaba.bytekit.asm.interceptor.annotation.AtEnter;
import com.alibaba.bytekit.asm.interceptor.annotation.AtExceptionExit;
import com.alibaba.bytekit.asm.interceptor.annotation.AtExit;
import com.alibaba.bytekit.asm.interceptor.annotation.AtInvoke;
import com.alibaba.bytekit.asm.interceptor.annotation.AtInvokeException;
/**
*
* @author hengyunabc 2020-06-05
*
*/
public class SpyInterceptors {
public static class SpyInterceptor1 {
@AtEnter(inline = true)
public static void atEnter(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.MethodInfo String methodInfo, @Binding.Args Object[] args) {
SpyAPI.atEnter(clazz, methodInfo, target, args);
}
}
public static class SpyInterceptor2 {
@AtExit(inline = true)
public static void atExit(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.MethodInfo String methodInfo, @Binding.Args Object[] args, @Binding.Return Object returnObj) {
SpyAPI.atExit(clazz, methodInfo, target, args, returnObj);
}
}
public static class SpyInterceptor3 {
@AtExceptionExit(inline = true)
public static void atExceptionExit(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.MethodInfo String methodInfo, @Binding.Args Object[] args,
@Binding.Throwable Throwable throwable) {
SpyAPI.atExceptionExit(clazz, methodInfo, target, args, throwable);
}
}
public static class SpyTraceInterceptor1 {
@AtInvoke(name = "", inline = true, whenComplete = false, excludes = {"java.arthas.SpyAPI", "java.lang.Byte"
, "java.lang.Boolean"
, "java.lang.Short"
, "java.lang.Character"
, "java.lang.Integer"
, "java.lang.Float"
, "java.lang.Long"
, "java.lang.Double"})
public static void onInvoke(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo) {
SpyAPI.atBeforeInvoke(clazz, invokeInfo, target);
}
}
public static class SpyTraceInterceptor2 {
@AtInvoke(name = "", inline = true, whenComplete = true, excludes = {"java.arthas.SpyAPI", "java.lang.Byte"
, "java.lang.Boolean"
, "java.lang.Short"
, "java.lang.Character"
, "java.lang.Integer"
, "java.lang.Float"
, "java.lang.Long"
, "java.lang.Double"})
public static void onInvokeAfter(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo) {
SpyAPI.atAfterInvoke(clazz, invokeInfo, target);
}
}
public static class SpyTraceInterceptor3 {
@AtInvokeException(name = "", inline = true, excludes = {"java.arthas.SpyAPI", "java.lang.Byte"
, "java.lang.Boolean"
, "java.lang.Short"
, "java.lang.Character"
, "java.lang.Integer"
, "java.lang.Float"
, "java.lang.Long"
, "java.lang.Double"})
public static void onInvokeException(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo, @Binding.Throwable Throwable throwable) {
SpyAPI.atInvokeException(clazz, invokeInfo, target, throwable);
}
}
public static class SpyTraceExcludeJDKInterceptor1 {
@AtInvoke(name = "", inline = true, whenComplete = false, excludes = "java.**")
public static void onInvoke(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo) {
SpyAPI.atBeforeInvoke(clazz, invokeInfo, target);
}
}
public static class SpyTraceExcludeJDKInterceptor2 {
@AtInvoke(name = "", inline = true, whenComplete = true, excludes = "java.**")
public static void onInvokeAfter(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo) {
SpyAPI.atAfterInvoke(clazz, invokeInfo, target);
}
}
public static class SpyTraceExcludeJDKInterceptor3 {
@AtInvokeException(name = "", inline = true, excludes = "java.**")
public static void onInvokeException(@Binding.This Object target, @Binding.Class Class<?> clazz,
@Binding.InvokeInfo String invokeInfo, @Binding.Throwable Throwable throwable) {
SpyAPI.atInvokeException(clazz, invokeInfo, target, throwable);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/AdviceListener.java | core/src/main/java/com/taobao/arthas/core/advisor/AdviceListener.java | package com.taobao.arthas.core.advisor;
/**
* 通知监听器<br/>
* Created by vlinux on 15/5/17.
*/
public interface AdviceListener {
long id();
/**
* 监听器创建<br/>
* 监听器被注册时触发
*/
void create();
/**
* 监听器销毁<br/>
* 监听器被销毁时触发
*/
void destroy();
/**
* 前置通知
*
* @param clazz 类
* @param methodName 方法名
* @param methodDesc 方法描述
* @param target 目标类实例
* 若目标为静态方法,则为null
* @param args 参数列表
* @throws Throwable 通知过程出错
*/
void before(
Class<?> clazz, String methodName, String methodDesc,
Object target, Object[] args) throws Throwable;
/**
* 返回通知
*
* @param clazz 类
* @param methodName 方法名
* @param methodDesc 方法描述
* @param target 目标类实例
* 若目标为静态方法,则为null
* @param args 参数列表
* @param returnObject 返回结果
* 若为无返回值方法(void),则为null
* @throws Throwable 通知过程出错
*/
void afterReturning(
Class<?> clazz, String methodName, String methodDesc,
Object target, Object[] args,
Object returnObject) throws Throwable;
/**
* 异常通知
*
* @param clazz 类
* @param methodName 方法名
* @param methodDesc 方法描述
* @param target 目标类实例
* 若目标为静态方法,则为null
* @param args 参数列表
* @param throwable 目标异常
* @throws Throwable 通知过程出错
*/
void afterThrowing(
Class<?> clazz, String methodName, String methodDesc,
Object target, Object[] args,
Throwable throwable) throws Throwable;
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/SpyImpl.java | core/src/main/java/com/taobao/arthas/core/advisor/SpyImpl.java | package com.taobao.arthas.core.advisor;
import java.arthas.SpyAPI.AbstractSpy;
import java.util.List;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.system.ProcessAware;
import com.taobao.arthas.core.util.StringUtils;
/**
* <pre>
* 怎么从 className|methodDesc 到 id 对应起来？？
* 当id少时，可以id自己来判断是否符合？
*
* 如果是每个 className|methodDesc 为 key ，是否
* </pre>
*
* @author hengyunabc 2020-04-24
*
*/
public class SpyImpl extends AbstractSpy {
private static final Logger logger = LoggerFactory.getLogger(SpyImpl.class);
@Override
public void atEnter(Class<?> clazz, String methodInfo, Object target, Object[] args) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
// TODO listener 只用查一次，放到 thread local里保存起来就可以了！
List<AdviceListener> listeners = AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.before(clazz, methodName, methodDesc, target, args);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atExit(Class<?> clazz, String methodInfo, Object target, Object[] args, Object returnObject) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
List<AdviceListener> listeners = AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.afterReturning(clazz, methodName, methodDesc, target, args, returnObject);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atExceptionExit(Class<?> clazz, String methodInfo, Object target, Object[] args, Throwable throwable) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
List<AdviceListener> listeners = AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.afterThrowing(clazz, methodName, methodDesc, target, args, throwable);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atBeforeInvoke(Class<?> clazz, String invokeInfo, Object target) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeBeforeTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
@Override
public void atAfterInvoke(Class<?> clazz, String invokeInfo, Object target) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeAfterTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
@Override
public void atInvokeException(Class<?> clazz, String invokeInfo, Object target, Throwable throwable) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeThrowTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
private static boolean skipAdviceListener(AdviceListener adviceListener) {
if (adviceListener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) adviceListener;
Process process = processAware.getProcess();
if (process == null) {
return true;
}
ExecStatus status = process.status();
if (status.equals(ExecStatus.TERMINATED) || status.equals(ExecStatus.STOPPED)) {
return true;
}
}
return false;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/AdviceWeaver.java | core/src/main/java/com/taobao/arthas/core/advisor/AdviceWeaver.java | package com.taobao.arthas.core.advisor;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
/**
* 通知编织者<br/>
* <p/>
* <h2>线程帧栈与执行帧栈</h2>
* 编织者在执行通知的时候有两个重要的栈:线程帧栈(threadFrameStack),执行帧栈(frameStack)
* <p/>
* Created by vlinux on 15/5/17.
*/
public class AdviceWeaver {
private static final Logger logger = LoggerFactory.getLogger(AdviceWeaver.class);
// 通知监听器集合
private final static Map<Long/*ADVICE_ID*/, AdviceListener> advices
= new ConcurrentHashMap<Long, AdviceListener>();
/**
* 注册监听器
*
* @param listener 通知监听器
*/
public static void reg(AdviceListener listener) {
// 触发监听器创建
listener.create();
// 注册监听器
advices.put(listener.id(), listener);
}
/**
* 注销监听器
*
* @param listener 通知监听器
*/
public static void unReg(AdviceListener listener) {
if (null != listener) {
// 注销监听器
advices.remove(listener.id());
// 触发监听器销毁
listener.destroy();
}
}
public static AdviceListener listener(long id) {
return advices.get(id);
}
/**
* 恢复监听
*
* @param listener 通知监听器
*/
public static void resume(AdviceListener listener) {
// 注册监听器
advices.put(listener.id(), listener);
}
/**
* 暂停监听
*
* @param adviceId 通知ID
*/
public static AdviceListener suspend(long adviceId) {
// 注销监听器
return advices.remove(adviceId);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/AdviceListenerManager.java | core/src/main/java/com/taobao/arthas/core/advisor/AdviceListenerManager.java | package com.taobao.arthas.core.advisor;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.concurrent.ConcurrentWeakKeyHashMap;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.system.ProcessAware;
/**
*
* TODO line 的记录 listener方式？ 还是有string为key，不过 classname|method|desc|num 这样子？
* 判断是否已插入了，可以在两行中间查询，有没有 SpyAPI 的invoke?
*
* TODO trace的怎么搞？ trace 只记录一次就可以了 classname|method|desc|trace ? 怎么避免 trace 到
* SPY的invoke ？直接忽略？
*
* TODO trace命令可以动态的增加 新的函数进去不？只要关联上同一个 Listener应该是可以的。
*
* TODO 在SPY里放很多的 Object数组，然后动态的设置进去？ 比如有新的 Listener来的时候。 这样子连查表都不用了。 甚至可以动态生成
* 存放这些 Listener数组的类？ 这样子的话，只要有 Binding那里，查询到一个具体分配好的类， 这样子就可以了？
* 甚至每个ClassLoader里都动态生成这样子的 存放类，那么这样子不可以避免查 ClassLoader了么？
*
* 动态为每一个增强类，生成一个新的类，新的类里，有各种的 ID 数组，保存每一个类的每一种 trace 点的信息？？
*
* 多个 watch命令 对同一个类，现在的逻辑是，每个watch都有一个自己的 TransForm，但不会重复增强，因为做了判断。
* watch命令停止时，也没有去掉增强的代码。 只有reset时 才会去掉。
*
* 其实用户想查看局部变量，并不是想查看哪一行！ 而是想看某个函数里子调用时的 局部变量的值！ 所以实际上是想要一个新的命令，比如 watchinmethod
* ， 可以 在某个子调用里，
*
* TODO 现在的trace 可以输出行号，可能不是很精确，但是可以对应上的。 这个在新的方式里怎么支持？ 增加一个 linenumber binding？
* 从mehtodNode，向上查找到最近的行号？
*
* TODO 防止重复增强，最重要的应该还是动态增加 annotation，这个才是真正可以做到某一行，某一个子 invoke 都能识别出来的！ 无论是
* transform多少次！ 字节码怎么动态加 annotation ？ annotation里签名用 url ?的key/value方式表达！
* 这样子可以有效还原信息
*
* TODO 是否考虑一个 trace /watch命令之后，得到一个具体的 Listener ID， 允许在另外的窗口里，再次
* trace/watch时指定这个ID，就会查找到，并处理。 这样子的话，真正达到了动态灵活的，一层一层增加的trace ！
*
*
* @author hengyunabc 2020-04-24
*
*/
public class AdviceListenerManager {
private static final Logger logger = LoggerFactory.getLogger(AdviceListenerManager.class);
private static final FakeBootstrapClassLoader FAKEBOOTSTRAPCLASSLOADER = new FakeBootstrapClassLoader();
static {
// 清理失效的 AdviceListener
ArthasBootstrap.getInstance().getScheduledExecutorService().scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
try {
for (Entry<ClassLoader, ClassLoaderAdviceListenerManager> entry : adviceListenerMap.entrySet()) {
ClassLoaderAdviceListenerManager adviceListenerManager = entry.getValue();
synchronized (adviceListenerManager) {
for (Entry<String, List<AdviceListener>> eee : adviceListenerManager.map.entrySet()) {
List<AdviceListener> listeners = eee.getValue();
List<AdviceListener> newResult = new ArrayList<AdviceListener>();
for (AdviceListener listener : listeners) {
if (listener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) listener;
Process process = processAware.getProcess();
if (process == null) {
continue;
}
ExecStatus status = process.status();
if (!status.equals(ExecStatus.TERMINATED)) {
newResult.add(listener);
}
}
}
if (newResult.size() != listeners.size()) {
adviceListenerManager.map.put(eee.getKey(), newResult);
}
}
}
}
} catch (Throwable e) {
try {
logger.error("clean AdviceListener error", e);
} catch (Throwable t) {
// ignore
}
}
}
}, 3, 3, TimeUnit.SECONDS);
}
private static final ConcurrentWeakKeyHashMap<ClassLoader, ClassLoaderAdviceListenerManager> adviceListenerMap = new ConcurrentWeakKeyHashMap<ClassLoader, ClassLoaderAdviceListenerManager>();
static class ClassLoaderAdviceListenerManager {
private ConcurrentHashMap<String, List<AdviceListener>> map = new ConcurrentHashMap<String, List<AdviceListener>>();
private String key(String className, String methodName, String methodDesc) {
return className + methodName + methodDesc;
}
private String keyForTrace(String className, String owner, String methodName, String methodDesc) {
return className + owner + methodName + methodDesc;
}
public void registerAdviceListener(String className, String methodName, String methodDesc,
AdviceListener listener) {
synchronized (this) {
className = className.replace('/', '.');
String key = key(className, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
if (listeners == null) {
listeners = new ArrayList<AdviceListener>();
map.put(key, listeners);
}
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
}
public List<AdviceListener> queryAdviceListeners(String className, String methodName, String methodDesc) {
className = className.replace('/', '.');
String key = key(className, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
return listeners;
}
public void registerTraceAdviceListener(String className, String owner, String methodName, String methodDesc,
AdviceListener listener) {
synchronized (this) {
className = className.replace('/', '.');
String key = keyForTrace(className, owner, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
if (listeners == null) {
listeners = new ArrayList<AdviceListener>();
map.put(key, listeners);
}
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
}
public List<AdviceListener> queryTraceAdviceListeners(String className, String owner, String methodName,
String methodDesc) {
className = className.replace('/', '.');
String key = keyForTrace(className, owner, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
return listeners;
}
}
public static void registerAdviceListener(ClassLoader classLoader, String className, String methodName,
String methodDesc, AdviceListener listener) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
logger.info("registerAdviceListener: classLoader={}, className={}, methodName={}, methodDesc={}, listener={}",
classLoader, className, methodName, methodDesc, listener.id());
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager == null) {
manager = new ClassLoaderAdviceListenerManager();
adviceListenerMap.put(classLoader, manager);
}
manager.registerAdviceListener(className, methodName, methodDesc, listener);
}
public static void updateAdviceListeners() {
}
public static List<AdviceListener> queryAdviceListeners(ClassLoader classLoader, String className,
String methodName, String methodDesc) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager != null) {
return manager.queryAdviceListeners(className, methodName, methodDesc);
}
return null;
}
public static void registerTraceAdviceListener(ClassLoader classLoader, String className, String owner,
String methodName, String methodDesc, AdviceListener listener) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager == null) {
manager = new ClassLoaderAdviceListenerManager();
adviceListenerMap.put(classLoader, manager);
}
manager.registerTraceAdviceListener(className, owner, methodName, methodDesc, listener);
}
public static List<AdviceListener> queryTraceAdviceListeners(ClassLoader classLoader, String className,
String owner, String methodName, String methodDesc) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager != null) {
return manager.queryTraceAdviceListeners(className, owner, methodName, methodDesc);
}
return null;
}
private static ClassLoader wrap(ClassLoader classLoader) {
if (classLoader != null) {
return classLoader;
}
return FAKEBOOTSTRAPCLASSLOADER;
}
private static class FakeBootstrapClassLoader extends ClassLoader {
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/advisor/TransformerManager.java | core/src/main/java/com/taobao/arthas/core/advisor/TransformerManager.java | package com.taobao.arthas.core.advisor;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
/**
*
* <pre>
* * 统一管理 ClassFileTransformer
* * 每个增强命令对应一个 Enhancer ，也统一在这里管理
* </pre>
*
* @see com.taobao.arthas.core.advisor.Enhancer
* @author hengyunabc 2020-05-18
*
*/
public class TransformerManager {
private Instrumentation instrumentation;
private List<ClassFileTransformer> watchTransformers = new CopyOnWriteArrayList<ClassFileTransformer>();
private List<ClassFileTransformer> traceTransformers = new CopyOnWriteArrayList<ClassFileTransformer>();
/**
* 先于 watch/trace的 Transformer TODO 改进为全部用 order 排序？
*/
private List<ClassFileTransformer> reTransformers = new CopyOnWriteArrayList<ClassFileTransformer>();
/**
* 懒加载模式的 Transformer，用于在类首次加载时增强
* 这些 transformer 需要用 addTransformer(transformer, false) 注册才能在类首次加载时工作
*/
private List<ClassFileTransformer> lazyTransformers = new CopyOnWriteArrayList<ClassFileTransformer>();
private ClassFileTransformer classFileTransformer;
/**
* 用于处理类首次加载的 transformer（非 retransform-capable）
* 只有这种 transformer 才会在类首次定义时被调用
*/
private ClassFileTransformer lazyClassFileTransformer;
public TransformerManager(Instrumentation instrumentation) {
this.instrumentation = instrumentation;
classFileTransformer = new ClassFileTransformer() {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
for (ClassFileTransformer classFileTransformer : reTransformers) {
byte[] transformResult = classFileTransformer.transform(loader, className, classBeingRedefined,
protectionDomain, classfileBuffer);
if (transformResult != null) {
classfileBuffer = transformResult;
}
}
for (ClassFileTransformer classFileTransformer : watchTransformers) {
byte[] transformResult = classFileTransformer.transform(loader, className, classBeingRedefined,
protectionDomain, classfileBuffer);
if (transformResult != null) {
classfileBuffer = transformResult;
}
}
for (ClassFileTransformer classFileTransformer : traceTransformers) {
byte[] transformResult = classFileTransformer.transform(loader, className, classBeingRedefined,
protectionDomain, classfileBuffer);
if (transformResult != null) {
classfileBuffer = transformResult;
}
}
return classfileBuffer;
}
};
instrumentation.addTransformer(classFileTransformer, true);
// 懒加载 transformer，用于在类首次加载时增强
// 注意：必须用 addTransformer(transformer, false) 才能在类首次定义时被调用
lazyClassFileTransformer = new ClassFileTransformer() {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
// 只处理类首次加载的情况（classBeingRedefined == null）
if (classBeingRedefined != null) {
return null;
}
for (ClassFileTransformer transformer : lazyTransformers) {
byte[] transformResult = transformer.transform(loader, className, classBeingRedefined,
protectionDomain, classfileBuffer);
if (transformResult != null) {
classfileBuffer = transformResult;
}
}
return classfileBuffer;
}
};
// 使用 false 参数，这样才会在类首次定义时被调用
instrumentation.addTransformer(lazyClassFileTransformer, false);
}
public void addTransformer(ClassFileTransformer transformer, boolean isTracing) {
if (isTracing) {
traceTransformers.add(transformer);
} else {
watchTransformers.add(transformer);
}
}
/**
* 添加懒加载 transformer，用于在类首次加载时增强
*/
public void addLazyTransformer(ClassFileTransformer transformer) {
lazyTransformers.add(transformer);
}
public void addRetransformer(ClassFileTransformer transformer) {
reTransformers.add(transformer);
}
public void removeTransformer(ClassFileTransformer transformer) {
reTransformers.remove(transformer);
watchTransformers.remove(transformer);
traceTransformers.remove(transformer);
lazyTransformers.remove(transformer);
}
public void destroy() {
reTransformers.clear();
watchTransformers.clear();
traceTransformers.clear();
lazyTransformers.clear();
instrumentation.removeTransformer(classFileTransformer);
instrumentation.removeTransformer(lazyClassFileTransformer);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/ScriptSupportCommand.java | core/src/main/java/com/taobao/arthas/core/command/ScriptSupportCommand.java | package com.taobao.arthas.core.command;
import com.taobao.arthas.core.advisor.Advice;
/**
* 脚本支持命令
* Created by vlinux on 15/6/1.
*/
public interface ScriptSupportCommand {
/**
* 增强脚本监听器
*/
interface ScriptListener {
/**
* 脚本创建
*
* @param output 输出器
*/
void create(Output output);
/**
* 脚本销毁
*
* @param output 输出器
*/
void destroy(Output output);
/**
* 方法执行前
*
* @param output 输出器
* @param advice 通知点
*/
void before(Output output, Advice advice);
/**
* 方法正常返回
*
* @param output 输出器
* @param advice 通知点
*/
void afterReturning(Output output, Advice advice);
/**
* 方法异常返回
*
* @param output 输出器
* @param advice 通知点
*/
void afterThrowing(Output output, Advice advice);
}
/**
* 脚本监听器适配器
*/
class ScriptListenerAdapter implements ScriptListener {
@Override
public void create(Output output) {
}
@Override
public void destroy(Output output) {
}
@Override
public void before(Output output, Advice advice) {
}
@Override
public void afterReturning(Output output, Advice advice) {
}
@Override
public void afterThrowing(Output output, Advice advice) {
}
}
/**
* 输出器
*/
interface Output {
/**
* 输出字符串(不换行)
*
* @param string 待输出字符串
* @return this
*/
Output print(String string);
/**
* 输出字符串(换行)
*
* @param string 待输出字符串
* @return this
*/
Output println(String string);
/**
* 结束当前脚本
*
* @return this
*/
Output finish();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/BuiltinCommandPack.java | core/src/main/java/com/taobao/arthas/core/command/BuiltinCommandPack.java | package com.taobao.arthas.core.command;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.basic1000.*;
import com.taobao.arthas.core.command.hidden.JulyCommand;
import com.taobao.arthas.core.command.hidden.ThanksCommand;
import com.taobao.arthas.core.command.klass100.ClassLoaderCommand;
import com.taobao.arthas.core.command.klass100.DumpClassCommand;
import com.taobao.arthas.core.command.klass100.GetStaticCommand;
import com.taobao.arthas.core.command.klass100.JadCommand;
import com.taobao.arthas.core.command.klass100.MemoryCompilerCommand;
import com.taobao.arthas.core.command.klass100.OgnlCommand;
import com.taobao.arthas.core.command.klass100.RedefineCommand;
import com.taobao.arthas.core.command.klass100.RetransformCommand;
import com.taobao.arthas.core.command.klass100.SearchClassCommand;
import com.taobao.arthas.core.command.klass100.SearchMethodCommand;
import com.taobao.arthas.core.command.logger.LoggerCommand;
import com.taobao.arthas.core.command.monitor200.DashboardCommand;
import com.taobao.arthas.core.command.monitor200.HeapDumpCommand;
import com.taobao.arthas.core.command.monitor200.JvmCommand;
import com.taobao.arthas.core.command.monitor200.MBeanCommand;
import com.taobao.arthas.core.command.monitor200.MemoryCommand;
import com.taobao.arthas.core.command.monitor200.MonitorCommand;
import com.taobao.arthas.core.command.monitor200.PerfCounterCommand;
import com.taobao.arthas.core.command.monitor200.ProfilerCommand;
import com.taobao.arthas.core.command.monitor200.StackCommand;
import com.taobao.arthas.core.command.monitor200.ThreadCommand;
import com.taobao.arthas.core.command.monitor200.TimeTunnelCommand;
import com.taobao.arthas.core.command.monitor200.TraceCommand;
import com.taobao.arthas.core.command.monitor200.VmToolCommand;
import com.taobao.arthas.core.command.monitor200.WatchCommand;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandResolver;
import com.taobao.middleware.cli.annotations.Name;
/**
* TODO automatically discover the built-in commands.
* @author beiwei30 on 17/11/2016.
*/
public class BuiltinCommandPack implements CommandResolver {
private static final Logger logger = LoggerFactory.getLogger(BuiltinCommandPack.class);
private List<Command> commands = new ArrayList<Command>();
public BuiltinCommandPack(List<String> disabledCommands) {
initCommands(disabledCommands);
}
@Override
public List<Command> commands() {
return commands;
}
private void initCommands(List<String> disabledCommands) {
List<Class<? extends AnnotatedCommand>> commandClassList = new ArrayList<Class<? extends AnnotatedCommand>>(33);
commandClassList.add(HelpCommand.class);
commandClassList.add(AuthCommand.class);
commandClassList.add(KeymapCommand.class);
commandClassList.add(SearchClassCommand.class);
commandClassList.add(SearchMethodCommand.class);
commandClassList.add(ClassLoaderCommand.class);
commandClassList.add(JadCommand.class);
commandClassList.add(GetStaticCommand.class);
commandClassList.add(MonitorCommand.class);
commandClassList.add(StackCommand.class);
commandClassList.add(ThreadCommand.class);
commandClassList.add(TraceCommand.class);
commandClassList.add(WatchCommand.class);
commandClassList.add(TimeTunnelCommand.class);
commandClassList.add(JvmCommand.class);
commandClassList.add(MemoryCommand.class);
commandClassList.add(PerfCounterCommand.class);
// commandClassList.add(GroovyScriptCommand.class);
commandClassList.add(OgnlCommand.class);
commandClassList.add(MemoryCompilerCommand.class);
commandClassList.add(RedefineCommand.class);
commandClassList.add(RetransformCommand.class);
commandClassList.add(DashboardCommand.class);
commandClassList.add(DumpClassCommand.class);
commandClassList.add(HeapDumpCommand.class);
commandClassList.add(JulyCommand.class);
commandClassList.add(ThanksCommand.class);
commandClassList.add(OptionsCommand.class);
commandClassList.add(ClsCommand.class);
commandClassList.add(ResetCommand.class);
commandClassList.add(VersionCommand.class);
commandClassList.add(SessionCommand.class);
commandClassList.add(SystemPropertyCommand.class);
commandClassList.add(SystemEnvCommand.class);
commandClassList.add(VMOptionCommand.class);
commandClassList.add(LoggerCommand.class);
commandClassList.add(HistoryCommand.class);
commandClassList.add(CatCommand.class);
commandClassList.add(Base64Command.class);
commandClassList.add(EchoCommand.class);
commandClassList.add(PwdCommand.class);
commandClassList.add(MBeanCommand.class);
commandClassList.add(GrepCommand.class);
commandClassList.add(TeeCommand.class);
commandClassList.add(ProfilerCommand.class);
commandClassList.add(VmToolCommand.class);
commandClassList.add(StopCommand.class);
try {
if (ClassLoader.getSystemClassLoader().getResource("jdk/jfr/Recording.class") != null) {
commandClassList.add(JFRCommand.class);
}
} catch (Throwable e) {
logger.error("This jdk version not support jfr command");
}
for (Class<? extends AnnotatedCommand> clazz : commandClassList) {
Name name = clazz.getAnnotation(Name.class);
if (name != null && name.value() != null) {
if (disabledCommands.contains(name.value())) {
continue;
}
}
commands.add(Command.create(clazz));
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/Constants.java | core/src/main/java/com/taobao/arthas/core/command/Constants.java | package com.taobao.arthas.core.command;
/**
* @author ralf0131 2016-12-14 17:21.
* @author hengyunabc 2018-12-03
*/
public interface Constants {
/**
* TODO improve the description
*/
String EXPRESS_DESCRIPTION = " The express may be one of the following expression (evaluated dynamically):\n" +
" target : the object\n" +
" clazz : the object's class\n" +
" method : the constructor or method\n" +
" params : the parameters array of method\n" +
" params[0..n] : the element of parameters array\n" +
" returnObj : the returned object of method\n" +
" throwExp : the throw exception of method\n" +
" isReturn : the method ended by return\n" +
" isThrow : the method ended by throwing exception\n" +
" #cost : the execution time in ms of method invocation";
String EXAMPLE = "\nEXAMPLES:\n";
String WIKI = "\nWIKI:\n";
String WIKI_HOME = " https://arthas.aliyun.com/doc/";
String EXPRESS_EXAMPLES = "Examples:\n" +
" params\n" +
" params[0]\n" +
" 'params[0]+params[1]'\n" +
" '{params[0], target, returnObj}'\n" +
" returnObj\n" +
" throwExp\n" +
" target\n" +
" clazz\n" +
" method\n";
String CONDITION_EXPRESS = "Conditional expression in ognl style, for example:\n" +
" TRUE : 1==1\n" +
" TRUE : true\n" +
" FALSE : false\n" +
" TRUE : 'params.length>=0'\n" +
" FALSE : 1==2\n" +
" '#cost>100'\n";
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/CommandExecutorImpl.java | core/src/main/java/com/taobao/arthas/core/command/CommandExecutorImpl.java | package com.taobao.arthas.core.command;
import com.taobao.arthas.common.PidUtils;
import com.taobao.arthas.core.command.model.*;
import com.taobao.arthas.core.distribution.ResultConsumer;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.distribution.SharingResultDistributor;
import com.taobao.arthas.core.distribution.impl.PackingResultDistributorImpl;
import com.taobao.arthas.core.distribution.impl.ResultConsumerImpl;
import com.taobao.arthas.core.distribution.impl.SharingResultDistributorImpl;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.CliTokens;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.session.SessionManager;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.JobController;
import com.taobao.arthas.core.shell.system.JobListener;
import com.taobao.arthas.core.shell.system.impl.InternalCommandManager;
import com.taobao.arthas.core.shell.term.SignalHandler;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.util.ArthasBanner;
import com.taobao.arthas.core.util.DateUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.mcp.server.CommandExecutor;
import io.termd.core.function.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import static com.taobao.arthas.common.ArthasConstants.SUBJECT_KEY;
/**
* 命令执行器，用于执行Arthas命令，支持同步和异步执行
*/
public class CommandExecutorImpl implements CommandExecutor {
private static final Logger logger = LoggerFactory.getLogger(CommandExecutorImpl.class);
private static final String ONETIME_SESSION_KEY = "oneTimeSession";
private final SessionManager sessionManager;
private final JobController jobController;
private final InternalCommandManager commandManager;
public CommandExecutorImpl(SessionManager sessionManager) {
this.sessionManager = sessionManager;
this.commandManager = sessionManager.getCommandManager();
this.jobController = sessionManager.getJobController();
}
public Session getCurrentSession(String sessionId, boolean oneTimeIsAllowed) {
if (sessionId == null || sessionId.trim().isEmpty()) {
if (!oneTimeIsAllowed) {
throw new SessionNotFoundException("SessionId is required for this operation");
}
Session session = sessionManager.createSession();
if (session == null) {
throw new SessionNotFoundException("Failed to create temporary session");
}
session.put(ONETIME_SESSION_KEY, new Object());
logger.debug("Created one-time session {}", session.getSessionId());
return session;
} else {
Session session = sessionManager.getSession(sessionId);
if (session == null) {
throw new SessionNotFoundException("Session not found: " + sessionId);
}
sessionManager.updateAccessTime(session);
logger.debug("Using existing session {}", sessionId);
return session;
}
}
/**
* 内部同步执行方法，统一处理认证和session管理
*
* @param commandLine 命令行
* @param timeout 超时时间
* @param sessionId session ID，如果为null则创建临时session
* @param authSubject 认证主体，如果不为null则应用到session
* @param userId 用户 ID，用于统计上报
* @return 执行结果
*/
@Override
public Map<String, Object> executeSync(String commandLine, long timeout, String sessionId, Object authSubject, String userId) {
Session session = null;
boolean oneTimeAccess = false;
try {
session = getCurrentSession(sessionId, true);
if (authSubject != null) {
session.put(SUBJECT_KEY, authSubject);
logger.debug("Applied auth subject to session: {} (authSubject: {})",
session.getSessionId(), authSubject.getClass().getSimpleName());
}
// 设置 userId 到 session，用于统计上报
if (userId != null && !userId.trim().isEmpty()) {
session.setUserId(userId);
logger.debug("Set userId to session: {} (userId: {})", session.getSessionId(), userId);
}
if (session.get(ONETIME_SESSION_KEY) != null) {
oneTimeAccess = true;
}
PackingResultDistributorImpl resultDistributor = new PackingResultDistributorImpl(session);
Job job = this.createJob(commandLine, session, resultDistributor);
if (job == null) {
logger.error("Failed to create job for command: {}", commandLine);
return createErrorResult(commandLine, "Failed to create job");
}
job.run();
boolean finished = waitForJob(job, (int) timeout);
if (!finished) {
logger.warn("Command timeout after {} ms: {}", timeout, commandLine);
job.interrupt();
return createTimeoutResult(commandLine, timeout);
}
Map<String, Object> result = new TreeMap<>();
result.put("command", commandLine);
result.put("success", true);
result.put("sessionId", session.getSessionId());
result.put("executionTime", System.currentTimeMillis());
List<ResultModel> results = resultDistributor.getResults();
if (results != null && !results.isEmpty()) {
result.put("results", results);
result.put("resultCount", results.size());
} else {
result.put("results", results);
result.put("resultCount", 0);
}
return result;
} catch (SessionNotFoundException e) {
logger.error("Session error for command: {}", commandLine, e);
return createErrorResult(commandLine, e.getMessage());
} catch (Exception e) {
logger.error("Error executing command: {}", commandLine, e);
return createErrorResult(commandLine, "Error executing command: " + e.getMessage());
} finally {
if (oneTimeAccess && session != null) {
try {
sessionManager.removeSession(session.getSessionId());
logger.debug("Destroyed one-time session {}", session.getSessionId());
} catch (Exception e) {
logger.warn("Error removing one-time session", e);
}
}
}
}
@Override
public Map<String, Object> executeAsync(String commandLine, String sessionId) {
Map<String, Object> result = new TreeMap<>();
Session session = getCurrentSession(sessionId, false);
if (!session.tryLock()) {
logger.warn("Another command is executing in session: {}", session.getSessionId());
return createErrorResult(commandLine, "Another command is executing");
}
int lock = session.getLock();
try {
Job foregroundJob = session.getForegroundJob();
if (foregroundJob != null) {
logger.warn("Another job is running in session: {}, jobId: {}", session.getSessionId(), foregroundJob.id());
session.unLock();
return createErrorResult(commandLine, "Another job is running, jobId: " + foregroundJob.id());
}
Job job = this.createJob(commandLine, session, session.getResultDistributor());
if (job == null) {
logger.error("Failed to create job for command: {}", commandLine);
session.unLock();
return createErrorResult(commandLine, "Failed to create job");
}
session.setForegroundJob(job);
updateSessionInputStatus(session, InputStatus.ALLOW_INTERRUPT);
job.run();
result.put("success", true);
result.put("command", commandLine);
result.put("sessionId", session.getSessionId());
result.put("jobId", job.id());
result.put("jobStatus", job.status().toString());
return result;
} catch (SessionNotFoundException e) {
logger.error("Session error for async command: {}", commandLine, e);
return createErrorResult(commandLine, e.getMessage());
} catch (Exception e) {
logger.error("Error executing async command: {}", commandLine, e);
return createErrorResult(commandLine, "Error executing async command: " + e.getMessage());
}finally {
if (session.getLock() == lock) {
session.unLock();
}
}
}
@Override
public Map<String, Object> pullResults(String sessionId, String consumerId) {
if (StringUtils.isBlank(consumerId)) {
return createErrorResult(null, "Consumer ID is null or empty");
}
try {
Session session = getCurrentSession(sessionId, false);
SharingResultDistributor resultDistributor = session.getResultDistributor();
if (resultDistributor == null) {
return createErrorResult(null, "No result distributor found for session: " + sessionId);
}
ResultConsumer consumer = resultDistributor.getConsumer(consumerId);
if (consumer == null) {
return createErrorResult(null, "Consumer not found: " + consumerId);
}
List<ResultModel> results = consumer.pollResults();
if (results != null && results.isEmpty()) {
logger.debug("Filtered empty result list for session: {}, consumer: {}", sessionId, consumerId);
return null;
}
Map<String, Object> result = new TreeMap<>();
result.put("success", true);
result.put("sessionId", sessionId);
result.put("consumerId", consumerId);
result.put("results", results);
Job foregroundJob = session.getForegroundJob();
if (foregroundJob != null) {
result.put("jobId", foregroundJob.id());
result.put("jobStatus", foregroundJob.status().toString());
}
return result;
} catch (SessionNotFoundException e) {
return createErrorResult(null, e.getMessage());
}
}
@Override
public Map<String, Object> interruptJob(String sessionId) {
try {
Session session = getCurrentSession(sessionId, false);
Job job = session.getForegroundJob();
if (job == null) {
return createErrorResult(null, "no foreground job is running");
}
job.interrupt();
Map<String, Object> result = new TreeMap<>();
result.put("success", true);
result.put("sessionId", sessionId);
result.put("jobId", job.id());
result.put("jobStatus", job.status().toString());
return result;
} catch (SessionNotFoundException e) {
return createErrorResult(null, e.getMessage());
}
}
@Override
public Map<String, Object> createSession() {
Session session = sessionManager.createSession();
if (session == null) {
return createErrorResult(null, "create api session failed");
}
SharingResultDistributorImpl resultDistributor = new SharingResultDistributorImpl(session);
ResultConsumer resultConsumer = new ResultConsumerImpl();
resultDistributor.addConsumer(resultConsumer);
session.setResultDistributor(resultDistributor);
resultDistributor.appendResult(new MessageModel("Welcome to arthas!"));
WelcomeModel welcomeModel = new WelcomeModel();
welcomeModel.setVersion(ArthasBanner.version());
welcomeModel.setWiki(ArthasBanner.wiki());
welcomeModel.setTutorials(ArthasBanner.tutorials());
welcomeModel.setMainClass(PidUtils.mainClass());
welcomeModel.setPid(PidUtils.currentPid());
welcomeModel.setTime(DateUtils.getCurrentDateTime());
resultDistributor.appendResult(welcomeModel);
updateSessionInputStatus(session, InputStatus.ALLOW_INPUT);
Map<String, Object> result = new TreeMap<>();
result.put("success", true);
result.put("sessionId", session.getSessionId());
result.put("consumerId", resultConsumer.getConsumerId());
return result;
}
@Override
public Map<String, Object> closeSession(String sessionId) {
try {
Session session = getCurrentSession(sessionId, false);
if (session.isLocked()) {
session.unLock();
}
sessionManager.removeSession(session.getSessionId());
Map<String, Object> result = new TreeMap<>();
result.put("success", true);
result.put("sessionId", sessionId);
return result;
} catch (SessionNotFoundException e) {
return createErrorResult(null, e.getMessage());
}
}
@Override
public void setSessionAuth(String sessionId, Object authSubject) {
try {
Session session = getCurrentSession(sessionId, false);
if (authSubject != null) {
session.put(SUBJECT_KEY, authSubject);
}
} catch (SessionNotFoundException e) {
logger.warn("Cannot set auth for non-existent session: {}", sessionId);
}
}
@Override
public void setSessionUserId(String sessionId, String userId) {
try {
Session session = getCurrentSession(sessionId, false);
if (userId != null && !userId.trim().isEmpty()) {
session.setUserId(userId);
logger.debug("Set userId for session {}: {}", sessionId, userId);
}
} catch (SessionNotFoundException e) {
logger.warn("Cannot set userId for non-existent session: {}", sessionId);
}
}
private boolean waitForJob(Job job, int timeout) {
long startTime = System.currentTimeMillis();
while (true) {
switch (job.status()) {
case STOPPED:
case TERMINATED:
return true;
}
if (System.currentTimeMillis() - startTime > timeout) {
return false;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
}
private Map<String, Object> createErrorResult(String commandLine, String errorMessage) {
Map<String, Object> result = new TreeMap<>();
result.put("success", false);
result.put("error", errorMessage);
if (commandLine != null) {
result.put("command", commandLine);
}
return result;
}
private Map<String, Object> createTimeoutResult(String commandLine, long timeout) {
Map<String, Object> result = new TreeMap<>();
result.put("command", commandLine);
result.put("success", false);
result.put("error", "Command timeout after " + timeout + " ms");
result.put("timeout", true);
result.put("executionTime", System.currentTimeMillis());
return result;
}
private void updateSessionInputStatus(Session session, InputStatus inputStatus) {
SharingResultDistributor resultDistributor = session.getResultDistributor();
if (resultDistributor != null) {
resultDistributor.appendResult(new InputStatusModel(inputStatus));
}
}
private Job createJob(String line, Session session, ResultDistributor resultDistributor) {
return createJob(CliTokens.tokenize(line), session, resultDistributor);
}
private synchronized Job createJob(List<CliToken> args, Session session, ResultDistributor resultDistributor) {
Job job = jobController.createJob(commandManager, args, session, new JobHandler(session), new McpTerm(session), resultDistributor);
return job;
}
public static class SessionNotFoundException extends RuntimeException {
public SessionNotFoundException(String message) {
super(message);
}
}
private class JobHandler implements JobListener {
private final Session session;
public JobHandler(Session session) {
this.session = session;
}
@Override
public void onForeground(Job job) {
session.setForegroundJob(job);
}
@Override
public void onBackground(Job job) {
if (session.getForegroundJob() == job) {
session.setForegroundJob(null);
updateSessionInputStatus(session, InputStatus.ALLOW_INPUT);
session.unLock();
}
}
@Override
public void onTerminated(Job job) {
if (session.getForegroundJob() == job) {
session.setForegroundJob(null);
updateSessionInputStatus(session, InputStatus.ALLOW_INPUT);
session.unLock();
}
}
@Override
public void onSuspend(Job job) {
if (session.getForegroundJob() == job) {
session.setForegroundJob(null);
updateSessionInputStatus(session, InputStatus.ALLOW_INPUT);
session.unLock();
}
}
}
public static class McpTerm implements Term {
private Session session;
public McpTerm(Session session) {
this.session = session;
}
@Override
public Term resizehandler(Handler<Void> handler) {
return this;
}
@Override
public String type() {
return "mcp";
}
@Override
public int width() {
return 1000;
}
@Override
public int height() {
return 200;
}
@Override
public Term stdinHandler(Handler<String> handler) {
return this;
}
@Override
public Term stdoutHandler(Function<String, String> handler) {
return this;
}
@Override
public Term write(String data) {
return this;
}
@Override
public long lastAccessedTime() {
return session.getLastAccessTime();
}
@Override
public Term echo(String text) {
return this;
}
@Override
public Term setSession(Session session) {
return this;
}
@Override
public Term interruptHandler(SignalHandler handler) {
return this;
}
@Override
public Term suspendHandler(SignalHandler handler) {
return this;
}
@Override
public void readline(String prompt, Handler<String> lineHandler) {
}
@Override
public void readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler) {
}
@Override
public Term closeHandler(Handler<Void> handler) {
return this;
}
@Override
public void close() {
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/SearchClassCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/SearchClassCommand.java | package com.taobao.arthas.core.command.klass100;
import java.lang.instrument.Instrumentation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ClassDetailVO;
import com.taobao.arthas.core.command.model.SearchClassModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.ResultUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* 展示类信息
*
* @author vlinux
*/
@Name("sc")
@Summary("Search all the classes loaded by JVM")
@Description(Constants.EXAMPLE +
" sc -d org.apache.commons.lang.StringUtils\n" +
" sc -d org/apache/commons/lang/StringUtils\n" +
" sc -d *StringUtils\n" +
" sc -d -f org.apache.commons.lang.StringUtils\n" +
" sc -E org\\\\.apache\\\\.commons\\\\.lang\\\\.StringUtils\n" +
Constants.WIKI + Constants.WIKI_HOME + "sc")
public class SearchClassCommand extends AnnotatedCommand {
private String classPattern;
private boolean isDetail = false;
private boolean isField = false;
private boolean isRegEx = false;
private String hashCode = null;
private String classLoaderClass;
private String classLoaderToString;
private Integer expand;
private int numberOfLimit = 100;
@Argument(argName = "class-pattern", index = 0)
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = StringUtils.normalizeClassName(classPattern);
}
@Option(shortName = "d", longName = "details", flag = true)
@Description("Display the details of class")
public void setDetail(boolean detail) {
isDetail = detail;
}
@Option(shortName = "f", longName = "field", flag = true)
@Description("Display all the member variables")
public void setField(boolean field) {
isField = field;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (0 by default)")
public void setExpand(Integer expand) {
this.expand = expand;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special class's classLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "n", longName = "limits")
@Description("Maximum number of matching classes with details (100 by default)")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
@Option(shortName = "cs", longName = "classLoaderStr")
@Description("The return value of the special class's ClassLoader#toString().")
public void setClassLoaderToString(String classLoaderToString) {
this.classLoaderToString = classLoaderToString;
}
@Override
public void process(final CommandProcess process) {
// TODO: null check
RowAffect affect = new RowAffect();
Instrumentation inst = process.session().getInstrumentation();
if (hashCode == null && (classLoaderClass != null || classLoaderToString != null)) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoader(inst, classLoaderClass, classLoaderToString);
String tips = "";
if (classLoaderClass != null) {
tips = "class name: " + classLoaderClass;
}
if (classLoaderToString != null) {
tips = tips + (StringUtils.isEmpty(tips) ? "ClassLoader#toString(): " : ", ClassLoader#toString(): ") + classLoaderToString;
}
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
SearchClassModel searchclassModel = new SearchClassModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(searchclassModel);
process.end(-1, "Found more than one classloader by " + tips + ", please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by " + tips + ".");
return;
}
}
List<Class<?>> matchedClasses = new ArrayList<Class<?>>(SearchUtils.searchClass(inst, classPattern, isRegEx, hashCode));
Collections.sort(matchedClasses, new Comparator<Class<?>>() {
@Override
public int compare(Class<?> c1, Class<?> c2) {
return StringUtils.classname(c1).compareTo(StringUtils.classname(c2));
}
});
if (isDetail) {
if (numberOfLimit > 0 && matchedClasses.size() > numberOfLimit) {
process.end(-1, "The number of matching classes is greater than : " + numberOfLimit+". \n" +
"Please specify a more accurate 'class-patten' or use the parameter '-n' to change the maximum number of matching classes.");
return;
}
for (Class<?> clazz : matchedClasses) {
ClassDetailVO classInfo = ClassUtils.createClassInfo(clazz, isField, expand);
process.appendResult(new SearchClassModel(classInfo, isDetail, isField));
}
} else {
int pageSize = 256;
ResultUtils.processClassNames(matchedClasses, pageSize, new ResultUtils.PaginationHandler<List<String>>() {
@Override
public boolean handle(List<String> classNames, int segment) {
process.appendResult(new SearchClassModel(classNames, segment));
return true;
}
});
}
affect.rCnt(matchedClasses.size());
process.appendResult(new RowAffectModel(affect));
process.end();
}
@Override
public void complete(Completion completion) {
if (!CompletionUtils.completeClassName(completion)) {
super.complete(completion);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/MemoryCompilerCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/MemoryCompilerCommand.java | package com.taobao.arthas.core.command.klass100;
import java.io.File;
import java.lang.instrument.Instrumentation;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Collection;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.compiler.DynamicCompiler;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.MemoryCompilerModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.FileUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
*
* @author hengyunabc 2019-02-05
*
*/
@Name("mc")
@Summary("Memory compiler, compiles java files into bytecode and class files in memory.")
@Description(Constants.EXAMPLE + " mc /tmp/Test.java\n" + " mc -c 327a647b /tmp/Test.java\n"
+ " mc -d /tmp/output /tmp/ClassA.java /tmp/ClassB.java\n" + Constants.WIKI + Constants.WIKI_HOME
+ "mc")
public class MemoryCompilerCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(MemoryCompilerCommand.class);
private String directory;
private String hashCode;
private String classLoaderClass;
private String encoding;
private List<String> sourcefiles;
@Argument(argName = "sourcefiles", index = 0)
@Description("source files")
public void setClassPattern(List<String> sourcefiles) {
this.sourcefiles = sourcefiles;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special ClassLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(longName = "encoding")
@Description("Source file encoding")
public void setEncoding(String encoding) {
this.encoding = encoding;
}
@Option(shortName = "d", longName = "directory")
@Description("Sets the destination directory for class files")
public void setDirectory(String directory) {
this.directory = directory;
}
@Override
public void process(final CommandProcess process) {
RowAffect affect = new RowAffect();
try {
Instrumentation inst = process.session().getInstrumentation();
if (hashCode == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
MemoryCompilerModel memoryCompilerModel = new MemoryCompilerModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(memoryCompilerModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
ClassLoader classloader = null;
if (hashCode == null) {
classloader = ClassLoader.getSystemClassLoader();
} else {
classloader = ClassLoaderUtils.getClassLoader(inst, hashCode);
if (classloader == null) {
process.end(-1, "Can not find classloader with hashCode: " + hashCode + ".");
return;
}
}
DynamicCompiler dynamicCompiler = new DynamicCompiler(classloader);
Charset charset = Charset.defaultCharset();
if (encoding != null) {
charset = Charset.forName(encoding);
}
for (String sourceFile : sourcefiles) {
String sourceCode = FileUtils.readFileToString(new File(sourceFile), charset);
String name = new File(sourceFile).getName();
if (name.endsWith(".java")) {
name = name.substring(0, name.length() - ".java".length());
}
dynamicCompiler.addSource(name, sourceCode);
}
Map<String, byte[]> byteCodes = dynamicCompiler.buildByteCodes();
File outputDir = null;
if (this.directory != null) {
outputDir = new File(this.directory);
} else {
outputDir = new File("").getAbsoluteFile();
}
List<String> files = new ArrayList<String>();
for (Entry<String, byte[]> entry : byteCodes.entrySet()) {
File byteCodeFile = new File(outputDir, entry.getKey().replace('.', '/') + ".class");
FileUtils.writeByteArrayToFile(byteCodeFile, entry.getValue());
files.add(byteCodeFile.getAbsolutePath());
affect.rCnt(1);
}
process.appendResult(new MemoryCompilerModel(files));
process.appendResult(new RowAffectModel(affect));
process.end();
} catch (Throwable e) {
logger.warn("Memory compiler error", e);
process.end(-1, "Memory compiler error, exception message: " + e.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details.");
}
}
@Override
public void complete(Completion completion) {
if (!CompletionUtils.completeFilePath(completion)) {
super.complete(completion);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/RedefineCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/RedefineCommand.java | package com.taobao.arthas.core.command.klass100;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.Instrumentation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.RedefineModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* Redefine Classes.
*
* @author hengyunabc 2018-07-13
* @see java.lang.instrument.Instrumentation#redefineClasses(ClassDefinition...)
*/
@Name("redefine")
@Summary("Redefine classes. @see Instrumentation#redefineClasses(ClassDefinition...)")
@Description(Constants.EXAMPLE +
" redefine /tmp/Test.class\n" +
" redefine -c 327a647b /tmp/Test.class /tmp/Test\\$Inner.class \n" +
" redefine --classLoaderClass 'sun.misc.Launcher$AppClassLoader' /tmp/Test.class \n" +
Constants.WIKI + Constants.WIKI_HOME + "redefine")
public class RedefineCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(RedefineCommand.class);
private static final int MAX_FILE_SIZE = 10 * 1024 * 1024;
private String hashCode;
private String classLoaderClass;
private List<String> paths;
@Option(shortName = "c", longName = "classloader")
@Description("classLoader hashcode")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Argument(argName = "classfilePaths", index = 0)
@Description(".class file paths")
public void setPaths(List<String> paths) {
this.paths = paths;
}
@Override
public void process(CommandProcess process) {
RedefineModel redefineModel = new RedefineModel();
Instrumentation inst = process.session().getInstrumentation();
for (String path : paths) {
File file = new File(path);
if (!file.exists()) {
process.end(-1, "file does not exist, path:" + path);
return;
}
if (!file.isFile()) {
process.end(-1, "not a normal file, path:" + path);
return;
}
if (file.length() >= MAX_FILE_SIZE) {
process.end(-1, "file size: " + file.length() + " >= " + MAX_FILE_SIZE + ", path: " + path);
return;
}
}
Map<String, byte[]> bytesMap = new HashMap<String, byte[]>();
for (String path : paths) {
RandomAccessFile f = null;
try {
f = new RandomAccessFile(path, "r");
final byte[] bytes = new byte[(int) f.length()];
f.readFully(bytes);
final String clazzName = readClassName(bytes);
bytesMap.put(clazzName, bytes);
} catch (Exception e) {
logger.warn("load class file failed: "+path, e);
process.end(-1, "load class file failed: " +path+", error: " + e);
return;
} finally {
if (f != null) {
try {
f.close();
} catch (IOException e) {
// ignore
}
}
}
}
if (bytesMap.size() != paths.size()) {
process.end(-1, "paths may contains same class name!");
return;
}
List<ClassDefinition> definitions = new ArrayList<ClassDefinition>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if (bytesMap.containsKey(clazz.getName())) {
if (hashCode == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
RedefineModel classredefineModel = new RedefineModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(classredefineModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader != null && hashCode != null && !Integer.toHexString(classLoader.hashCode()).equals(hashCode)) {
continue;
}
definitions.add(new ClassDefinition(clazz, bytesMap.get(clazz.getName())));
redefineModel.addRedefineClass(clazz.getName());
logger.info("Try redefine class name: {}, ClassLoader: {}", clazz.getName(), clazz.getClassLoader());
}
}
try {
if (definitions.isEmpty()) {
process.end(-1, "These classes are not found in the JVM and may not be loaded: " + bytesMap.keySet());
return;
}
inst.redefineClasses(definitions.toArray(new ClassDefinition[0]));
process.appendResult(redefineModel);
process.end();
} catch (Throwable e) {
String message = "redefine error! " + e.toString();
logger.error(message, e);
process.end(-1, message);
}
}
private static String readClassName(final byte[] bytes) {
return new ClassReader(bytes).getClassName().replace("/", ".");
}
@Override
public void complete(Completion completion) {
if (!CompletionUtils.completeFilePath(completion)) {
super.complete(completion);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/ClassLoaderCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/ClassLoaderCommand.java | package com.taobao.arthas.core.command.klass100;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ClassDetailVO;
import com.taobao.arthas.core.command.model.ClassLoaderModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.ClassSetVO;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.ResultUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.lang.instrument.Instrumentation;
import java.net.URL;
import java.security.CodeSource;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;
@Name("classloader")
@Summary("Show classloader info")
@Description(Constants.EXAMPLE +
" classloader\n" +
" classloader -t\n" +
" classloader -l\n" +
" classloader -c 327a647b\n" +
" classloader -c 327a647b -r META-INF/MANIFEST.MF\n" +
" classloader -a\n" +
" classloader -a -c 327a647b\n" +
" classloader -c 659e0bfd --load demo.MathGame\n" +
" classloader -u # url statistics\n" +
" classloader -c 659e0bfd --url-classes\n" +
" classloader -c 659e0bfd --url-classes -d\n" +
" classloader -c 659e0bfd --url-classes --jar spring-core --class org.springframework\n" +
Constants.WIKI + Constants.WIKI_HOME + "classloader")
public class ClassLoaderCommand extends AnnotatedCommand {
private static Logger logger = LoggerFactory.getLogger(ClassLoaderCommand.class);
private static final int DEFAULT_URL_CLASSES_LIMIT = 100;
private static final String UNKNOWN_CODE_SOURCE = "<unknown>";
private boolean isTree = false;
private String hashCode;
private String classLoaderClass;
private boolean all = false;
private String resource;
private boolean includeReflectionClassLoader = true;
private boolean listClassLoader = false;
private boolean urlStat = false;
private boolean urlClasses = false;
private boolean urlClassesDetail = false;
private boolean urlClassesRegEx = false;
private int urlClassesLimit = DEFAULT_URL_CLASSES_LIMIT;
private String jarFilter;
private String classFilter;
private String loadClass = null;
private volatile boolean isInterrupted = false;
@Option(shortName = "t", longName = "tree", flag = true)
@Description("Display ClassLoader tree")
public void setTree(boolean tree) {
isTree = tree;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special ClassLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(shortName = "a", longName = "all", flag = true)
@Description("Display all classes loaded by ClassLoader")
public void setAll(boolean all) {
this.all = all;
}
@Option(shortName = "r", longName = "resource")
@Description("Use ClassLoader to find resources, won't work without -c specified")
public void setResource(String resource) {
this.resource = resource;
}
@Option(shortName = "i", longName = "include-reflection-classloader", flag = true)
@Description("Include sun.reflect.DelegatingClassLoader")
public void setIncludeReflectionClassLoader(boolean includeReflectionClassLoader) {
this.includeReflectionClassLoader = includeReflectionClassLoader;
}
@Option(shortName = "l", longName = "list-classloader", flag = true)
@Description("Display statistics info by classloader instance")
public void setListClassLoader(boolean listClassLoader) {
this.listClassLoader = listClassLoader;
}
@Option(longName = "load")
@Description("Use ClassLoader to load class, won't work without -c specified")
public void setLoadClass(String className) {
this.loadClass = className;
}
@Option(shortName = "u", longName = "url-stat", flag = true)
@Description("Display classloader url statistics")
public void setUrlStat(boolean urlStat) {
this.urlStat = urlStat;
}
@Option(longName = "url-classes", flag = true)
@Description("Display relationship between jar(URL) and loaded classes in the specified ClassLoader")
public void setUrlClasses(boolean urlClasses) {
this.urlClasses = urlClasses;
}
@Option(shortName = "d", longName = "details", flag = true)
@Description("Display class list for each jar(URL), only works with --url-classes")
public void setUrlClassesDetail(boolean urlClassesDetail) {
this.urlClassesDetail = urlClassesDetail;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match for --jar/--class, only works with --url-classes")
public void setUrlClassesRegEx(boolean urlClassesRegEx) {
this.urlClassesRegEx = urlClassesRegEx;
}
@Option(shortName = "n", longName = "limit")
@Description("Maximum number of classes to display per jar(URL) in details mode (100 by default), only works with --url-classes -d")
public void setUrlClassesLimit(int urlClassesLimit) {
this.urlClassesLimit = urlClassesLimit;
}
@Option(longName = "jar")
@Description("Filter jar(URL) by keyword (or regex with -E), only works with --url-classes")
public void setJarFilter(String jarFilter) {
this.jarFilter = jarFilter;
}
@Option(longName = "class")
@Description("Filter classes by keyword/package (or regex with -E), only works with --url-classes")
public void setClassFilter(String classFilter) {
this.classFilter = StringUtils.normalizeClassName(classFilter);
}
@Override
public void process(CommandProcess process) {
// ctrl-C support
process.interruptHandler(new ClassLoaderInterruptHandler(this));
ClassLoader targetClassLoader = null;
boolean classLoaderSpecified = false;
Instrumentation inst = process.session().getInstrumentation();
if (urlStat) {
Map<ClassLoaderVO, ClassLoaderUrlStat> urlStats = this.urlStats(inst);
ClassLoaderModel model = new ClassLoaderModel();
model.setUrlStats(urlStats);
process.appendResult(model);
process.end();
return;
}
if (!urlClasses && (urlClassesDetail || urlClassesRegEx || jarFilter != null || classFilter != null
|| urlClassesLimit != DEFAULT_URL_CLASSES_LIMIT)) {
process.end(-1, "Options -d/-E/-n/--jar/--class only work with --url-classes.");
return;
}
if (hashCode != null || classLoaderClass != null) {
classLoaderSpecified = true;
}
if (hashCode != null) {
Set<ClassLoader> allClassLoader = getAllClassLoaders(inst);
for (ClassLoader cl : allClassLoader) {
if (Integer.toHexString(cl.hashCode()).equals(hashCode)) {
targetClassLoader = cl;
break;
}
}
} else if (classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
targetClassLoader = matchedClassLoaders.get(0);
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
ClassLoaderModel classloaderModel = new ClassLoaderModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(classloaderModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
if (urlClasses) {
if (!classLoaderSpecified) {
process.end(-1, "Please specify classloader with '-c <classloader hash>' or '--classLoaderClass <classloader class name>' for --url-classes.");
return;
}
if (targetClassLoader == null) {
process.end(-1, "Can not find classloader by hashcode: " + hashCode + ".");
return;
}
processUrlClasses(process, inst, targetClassLoader);
return;
}
if (all) {
String hashCode = this.hashCode;
if (StringUtils.isBlank(hashCode) && targetClassLoader != null) {
hashCode = "" + Integer.toHexString(targetClassLoader.hashCode());
}
processAllClasses(process, inst, hashCode);
} else if (classLoaderSpecified && resource != null) {
processResources(process, inst, targetClassLoader);
} else if (classLoaderSpecified && this.loadClass != null) {
processLoadClass(process, inst, targetClassLoader);
} else if (classLoaderSpecified) {
processClassLoader(process, inst, targetClassLoader);
} else if (listClassLoader || isTree){
processClassLoaders(process, inst);
} else {
processClassLoaderStats(process, inst);
}
}
/**
* Calculate classloader statistics.
* e.g. In JVM, there are 100 GrooyClassLoader instances, which loaded 200 classes in total
* @param process
* @param inst
*/
private void processClassLoaderStats(CommandProcess process, Instrumentation inst) {
RowAffect affect = new RowAffect();
List<ClassLoaderInfo> classLoaderInfos = getAllClassLoaderInfo(inst);
Map<String, ClassLoaderStat> classLoaderStats = new HashMap<String, ClassLoaderStat>();
for (ClassLoaderInfo info: classLoaderInfos) {
String name = info.classLoader == null ? "BootstrapClassLoader" : info.classLoader.getClass().getName();
ClassLoaderStat stat = classLoaderStats.get(name);
if (null == stat) {
stat = new ClassLoaderStat();
classLoaderStats.put(name, stat);
}
stat.addLoadedCount(info.loadedClassCount);
stat.addNumberOfInstance(1);
}
// sort the map by value
TreeMap<String, ClassLoaderStat> sorted =
new TreeMap<String, ClassLoaderStat>(new ValueComparator(classLoaderStats));
sorted.putAll(classLoaderStats);
process.appendResult(new ClassLoaderModel().setClassLoaderStats(sorted));
affect.rCnt(sorted.keySet().size());
process.appendResult(new RowAffectModel(affect));
process.end();
}
private void processClassLoaders(CommandProcess process, Instrumentation inst) {
RowAffect affect = new RowAffect();
List<ClassLoaderInfo> classLoaderInfos = includeReflectionClassLoader ? getAllClassLoaderInfo(inst) :
getAllClassLoaderInfo(inst, new SunReflectionClassLoaderFilter());
List<ClassLoaderVO> classLoaderVOs = new ArrayList<ClassLoaderVO>(classLoaderInfos.size());
for (ClassLoaderInfo classLoaderInfo : classLoaderInfos) {
ClassLoaderVO classLoaderVO = ClassUtils.createClassLoaderVO(classLoaderInfo.classLoader);
classLoaderVO.setLoadedCount(classLoaderInfo.loadedClassCount());
classLoaderVOs.add(classLoaderVO);
}
if (isTree){
classLoaderVOs = processClassLoaderTree(classLoaderVOs);
}
process.appendResult(new ClassLoaderModel().setClassLoaders(classLoaderVOs).setTree(isTree));
affect.rCnt(classLoaderInfos.size());
process.appendResult(new RowAffectModel(affect));
process.end();
}
// 根据 ClassLoader 来打印URLClassLoader的urls
private void processClassLoader(CommandProcess process, Instrumentation inst, ClassLoader targetClassLoader) {
RowAffect affect = new RowAffect();
if (targetClassLoader != null) {
URL[] classLoaderUrls = ClassLoaderUtils.getUrls(targetClassLoader);
if (classLoaderUrls != null) {
affect.rCnt(classLoaderUrls.length);
if (classLoaderUrls.length == 0) {
process.appendResult(new MessageModel("urls is empty."));
} else {
process.appendResult(new ClassLoaderModel().setUrls(StringUtils.toStringList(classLoaderUrls)));
affect.rCnt(classLoaderUrls.length);
}
} else {
process.appendResult(new MessageModel("not a URLClassLoader."));
}
}
process.appendResult(new RowAffectModel(affect));
process.end();
}
// 使用ClassLoader去getResources
private void processResources(CommandProcess process, Instrumentation inst, ClassLoader targetClassLoader) {
RowAffect affect = new RowAffect();
int rowCount = 0;
List<String> resources = new ArrayList<String>();
if (targetClassLoader != null) {
try {
Enumeration<URL> urls = targetClassLoader.getResources(resource);
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
resources.add(url.toString());
rowCount++;
}
} catch (Throwable e) {
logger.warn("get resource failed, resource: {}", resource, e);
}
}
affect.rCnt(rowCount);
process.appendResult(new ClassLoaderModel().setResources(resources));
process.appendResult(new RowAffectModel(affect));
process.end();
}
// Use ClassLoader to loadClass
private void processLoadClass(CommandProcess process, Instrumentation inst, ClassLoader targetClassLoader) {
if (targetClassLoader != null) {
try {
Class<?> clazz = targetClassLoader.loadClass(this.loadClass);
process.appendResult(new MessageModel("load class success."));
ClassDetailVO classInfo = ClassUtils.createClassInfo(clazz, false, null);
process.appendResult(new ClassLoaderModel().setLoadClass(classInfo));
} catch (Throwable e) {
logger.warn("load class error, class: {}", this.loadClass, e);
process.end(-1, "load class error, class: "+this.loadClass+", error: "+e.toString());
return;
}
}
process.end();
}
private void processAllClasses(CommandProcess process, Instrumentation inst,String hashCode) {
RowAffect affect = new RowAffect();
getAllClasses(hashCode, inst, affect, process);
if (checkInterrupted(process)) {
return;
}
process.appendResult(new RowAffectModel(affect));
process.end();
}
/**
* 获取到所有的class, 还有它们的classloader，按classloader归类好，统一输出每个classloader里有哪些class
* <p>
* 当hashCode是null，则把所有的classloader的都打印
*
*/
@SuppressWarnings("rawtypes")
private void getAllClasses(String hashCode, Instrumentation inst, RowAffect affect, CommandProcess process) {
int hashCodeInt = -1;
if (hashCode != null) {
hashCodeInt = Integer.valueOf(hashCode, 16);
}
SortedSet<Class<?>> bootstrapClassSet = new TreeSet<Class<?>>(new Comparator<Class>() {
@Override
public int compare(Class o1, Class o2) {
return o1.getName().compareTo(o2.getName());
}
});
Class[] allLoadedClasses = inst.getAllLoadedClasses();
Map<ClassLoader, SortedSet<Class<?>>> classLoaderClassMap = new HashMap<ClassLoader, SortedSet<Class<?>>>();
for (Class clazz : allLoadedClasses) {
ClassLoader classLoader = clazz.getClassLoader();
// Class loaded by BootstrapClassLoader
if (classLoader == null) {
if (hashCode == null) {
bootstrapClassSet.add(clazz);
}
continue;
}
if (hashCode != null && classLoader.hashCode() != hashCodeInt) {
continue;
}
SortedSet<Class<?>> classSet = classLoaderClassMap.get(classLoader);
if (classSet == null) {
classSet = new TreeSet<Class<?>>(new Comparator<Class<?>>() {
@Override
public int compare(Class<?> o1, Class<?> o2) {
return o1.getName().compareTo(o2.getName());
}
});
classLoaderClassMap.put(classLoader, classSet);
}
classSet.add(clazz);
}
// output bootstrapClassSet
int pageSize = 256;
processClassSet(process, ClassUtils.createClassLoaderVO(null), bootstrapClassSet, pageSize, affect);
// output other classSet
for (Entry<ClassLoader, SortedSet<Class<?>>> entry : classLoaderClassMap.entrySet()) {
if (checkInterrupted(process)) {
return;
}
ClassLoader classLoader = entry.getKey();
SortedSet<Class<?>> classSet = entry.getValue();
processClassSet(process, ClassUtils.createClassLoaderVO(classLoader), classSet, pageSize, affect);
}
}
private void processClassSet(final CommandProcess process, final ClassLoaderVO classLoaderVO, Collection<Class<?>> classes, int pageSize, final RowAffect affect) {
//分批输出classNames, Ctrl+C可以中断执行
ResultUtils.processClassNames(classes, pageSize, new ResultUtils.PaginationHandler<List<String>>() {
@Override
public boolean handle(List<String> classNames, int segment) {
process.appendResult(new ClassLoaderModel().setClassSet(new ClassSetVO(classLoaderVO, classNames, segment)));
affect.rCnt(classNames.size());
return !checkInterrupted(process);
}
});
}
private boolean checkInterrupted(CommandProcess process) {
if (!process.isRunning()) {
return true;
}
if(isInterrupted){
process.end(-1, "Processing has been interrupted");
return true;
} else {
return false;
}
}
private void processUrlClasses(CommandProcess process, Instrumentation inst, ClassLoader targetClassLoader) {
if (!urlClassesDetail && urlClassesLimit != DEFAULT_URL_CLASSES_LIMIT) {
process.end(-1, "Option -n/--limit only works with --url-classes -d.");
return;
}
if (urlClassesDetail && urlClassesLimit <= 0) {
process.end(-1, "Option -n/--limit must be greater than 0.");
return;
}
Pattern jarPattern = null;
Pattern classPattern = null;
if (urlClassesRegEx) {
try {
if (jarFilter != null) {
jarPattern = Pattern.compile(jarFilter);
}
if (classFilter != null) {
classPattern = Pattern.compile(classFilter);
}
} catch (Throwable e) {
process.end(-1, "Regex compile error: " + e.getMessage());
return;
}
}
Map<String, UrlClassStatBuilder> statsMap = new HashMap<String, UrlClassStatBuilder>();
Class<?>[] allLoadedClasses = inst.getAllLoadedClasses();
for (int i = 0; i < allLoadedClasses.length; i++) {
if ((i & 0x3FFF) == 0 && checkInterrupted(process)) {
return;
}
Class<?> clazz = allLoadedClasses[i];
if (clazz == null) {
continue;
}
if (clazz.getClassLoader() != targetClassLoader) {
continue;
}
String url = codeSourceLocation(clazz);
if (!matchJarFilter(url, jarPattern)) {
continue;
}
UrlClassStatBuilder builder = statsMap.get(url);
if (builder == null) {
builder = new UrlClassStatBuilder(url, classFilter != null, urlClassesDetail ? urlClassesLimit : 0);
statsMap.put(url, builder);
}
builder.increaseLoadedCount();
if (classFilter != null) {
if (matchClassFilter(clazz.getName(), classPattern)) {
builder.increaseMatchedCount();
builder.tryAddClass(clazz.getName());
}
} else {
builder.tryAddClass(clazz.getName());
}
}
boolean hasClassFilter = classFilter != null;
List<UrlClassStat> stats = new ArrayList<UrlClassStat>(statsMap.size());
for (UrlClassStatBuilder builder : statsMap.values()) {
if (hasClassFilter && builder.getMatchedClassCount() == 0) {
continue;
}
stats.add(builder.build());
}
Collections.sort(stats, new Comparator<UrlClassStat>() {
@Override
public int compare(UrlClassStat o1, UrlClassStat o2) {
int c1 = hasClassFilter ? safeInt(o1.getMatchedClassCount()) : o1.getLoadedClassCount();
int c2 = hasClassFilter ? safeInt(o2.getMatchedClassCount()) : o2.getLoadedClassCount();
int diff = c2 - c1;
if (diff != 0) {
return diff;
}
return o1.getUrl().compareTo(o2.getUrl());
}
});
RowAffect affect = new RowAffect();
affect.rCnt(stats.size());
ClassLoaderModel model = new ClassLoaderModel()
.setClassLoader(ClassUtils.createClassLoaderVO(targetClassLoader))
.setUrlClassStats(stats)
.setUrlClassStatsDetail(urlClassesDetail);
process.appendResult(model);
process.appendResult(new RowAffectModel(affect));
process.end();
}
private static int safeInt(Integer v) {
return v == null ? 0 : v.intValue();
}
private boolean matchJarFilter(String url, Pattern jarPattern) {
if (jarFilter == null) {
return true;
}
String jarName = guessJarName(url);
if (urlClassesRegEx) {
return jarPattern != null && (jarPattern.matcher(url).find() || jarPattern.matcher(jarName).find());
}
return containsIgnoreCase(url, jarFilter) || containsIgnoreCase(jarName, jarFilter);
}
private boolean matchClassFilter(String className, Pattern classPattern) {
if (classFilter == null) {
return true;
}
if (urlClassesRegEx) {
return classPattern != null && classPattern.matcher(className).find();
}
return containsIgnoreCase(className, classFilter);
}
static boolean containsIgnoreCase(String text, String keyword) {
if (text == null || keyword == null) {
return false;
}
return text.toLowerCase().contains(keyword.toLowerCase());
}
private static String codeSourceLocation(Class<?> clazz) {
try {
ProtectionDomain protectionDomain = clazz.getProtectionDomain();
if (protectionDomain == null) {
return UNKNOWN_CODE_SOURCE;
}
CodeSource codeSource = protectionDomain.getCodeSource();
if (codeSource == null) {
return UNKNOWN_CODE_SOURCE;
}
URL location = codeSource.getLocation();
if (location == null) {
return UNKNOWN_CODE_SOURCE;
}
return location.toString();
} catch (Throwable t) {
return UNKNOWN_CODE_SOURCE;
}
}
static String guessJarName(String url) {
if (url == null) {
return com.taobao.arthas.core.util.Constants.EMPTY_STRING;
}
String s = url;
int bangIndex = s.lastIndexOf('!');
if (bangIndex >= 0) {
s = s.substring(0, bangIndex);
}
while (s.endsWith("/")) {
s = s.substring(0, s.length() - 1);
}
int slash = Math.max(s.lastIndexOf('/'), s.lastIndexOf('\\'));
if (slash >= 0 && slash < s.length() - 1) {
s = s.substring(slash + 1);
}
return s;
}
private Map<ClassLoaderVO, ClassLoaderUrlStat> urlStats(Instrumentation inst) {
Map<ClassLoaderVO, ClassLoaderUrlStat> urlStats = new HashMap<ClassLoaderVO, ClassLoaderUrlStat>();
Map<ClassLoader, Set<String>> usedUrlsMap = new HashMap<ClassLoader, Set<String>>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader != null) {
ProtectionDomain protectionDomain = clazz.getProtectionDomain();
CodeSource codeSource = protectionDomain.getCodeSource();
if (codeSource != null) {
URL location = codeSource.getLocation();
if (location != null) {
Set<String> urls = usedUrlsMap.get(classLoader);
if (urls == null) {
urls = new HashSet<String>();
usedUrlsMap.put(classLoader, urls);
}
urls.add(location.toString());
}
}
}
}
for (Entry<ClassLoader, Set<String>> entry : usedUrlsMap.entrySet()) {
ClassLoader loader = entry.getKey();
Set<String> usedUrls = entry.getValue();
URL[] allUrls = ClassLoaderUtils.getUrls(loader);
List<String> unusedUrls = new ArrayList<String>();
if (allUrls != null) {
for (URL url : allUrls) {
String urlStr = url.toString();
if (!usedUrls.contains(urlStr)) {
unusedUrls.add(urlStr);
}
}
}
urlStats.put(ClassUtils.createClassLoaderVO(loader), new ClassLoaderUrlStat(usedUrls, unusedUrls));
}
return urlStats;
}
// 以树状列出ClassLoader的继承结构
private static List<ClassLoaderVO> processClassLoaderTree(List<ClassLoaderVO> classLoaders) {
List<ClassLoaderVO> rootClassLoaders = new ArrayList<>();
Map<String, List<ClassLoaderVO>> childMap = new HashMap<>();
// 分离根节点和非根节点，并构建父子关系映射
for (ClassLoaderVO classLoaderVO : classLoaders) {
if (classLoaderVO.getParent() == null) {
rootClassLoaders.add(classLoaderVO);
} else {
childMap.computeIfAbsent(classLoaderVO.getParent(), k -> new ArrayList<>()).add(classLoaderVO);
}
}
// 构建树
for (ClassLoaderVO root : rootClassLoaders) {
buildTree(root, childMap);
}
return rootClassLoaders;
}
private static void buildTree(ClassLoaderVO parent, Map<String, List<ClassLoaderVO>> childMap) {
List<ClassLoaderVO> children = childMap.get(parent.getName());
if (children != null) {
for (ClassLoaderVO child : children) {
parent.addChild(child);
buildTree(child, childMap);
}
}
}
private static Set<ClassLoader> getAllClassLoaders(Instrumentation inst, Filter... filters) {
Set<ClassLoader> classLoaderSet = new HashSet<ClassLoader>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader != null) {
if (shouldInclude(classLoader, filters)) {
classLoaderSet.add(classLoader);
}
}
}
return classLoaderSet;
}
private static List<ClassLoaderInfo> getAllClassLoaderInfo(Instrumentation inst, Filter... filters) {
// 这里认为class.getClassLoader()返回是null的是由BootstrapClassLoader加载的，特殊处理
ClassLoaderInfo bootstrapInfo = new ClassLoaderInfo(null);
Map<ClassLoader, ClassLoaderInfo> loaderInfos = new HashMap<ClassLoader, ClassLoaderInfo>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader == null) {
bootstrapInfo.increase();
} else {
if (shouldInclude(classLoader, filters)) {
ClassLoaderInfo loaderInfo = loaderInfos.get(classLoader);
if (loaderInfo == null) {
loaderInfo = new ClassLoaderInfo(classLoader);
loaderInfos.put(classLoader, loaderInfo);
ClassLoader parent = classLoader.getParent();
while (parent != null) {
ClassLoaderInfo parentLoaderInfo = loaderInfos.get(parent);
if (parentLoaderInfo == null) {
parentLoaderInfo = new ClassLoaderInfo(parent);
loaderInfos.put(parent, parentLoaderInfo);
}
parent = parent.getParent();
}
}
loaderInfo.increase();
}
}
}
// 排序时，把用户自己定的ClassLoader排在最前面，以sun.
// 开头的放后面，因为sun.reflect.DelegatingClassLoader的实例太多
List<ClassLoaderInfo> sunClassLoaderList = new ArrayList<ClassLoaderInfo>();
List<ClassLoaderInfo> otherClassLoaderList = new ArrayList<ClassLoaderInfo>();
for (Entry<ClassLoader, ClassLoaderInfo> entry : loaderInfos.entrySet()) {
ClassLoader classLoader = entry.getKey();
if (classLoader.getClass().getName().startsWith("sun.")) {
sunClassLoaderList.add(entry.getValue());
} else {
otherClassLoaderList.add(entry.getValue());
}
}
Collections.sort(sunClassLoaderList);
Collections.sort(otherClassLoaderList);
List<ClassLoaderInfo> result = new ArrayList<ClassLoaderInfo>();
result.add(bootstrapInfo);
result.addAll(otherClassLoaderList);
result.addAll(sunClassLoaderList);
return result;
}
private static boolean shouldInclude(ClassLoader classLoader, Filter... filters) {
if (filters == null) {
return true;
}
for (Filter filter : filters) {
if (!filter.accept(classLoader)) {
return false;
}
}
return true;
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | true |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/JadCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/JadCommand.java | package com.taobao.arthas.core.command.klass100;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.Pair;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ClassVO;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.JadModel;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.ExitStatus;
import com.taobao.arthas.core.util.*;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.io.File;
import java.lang.instrument.Instrumentation;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Set;
import java.util.Collection;
import java.util.regex.Pattern;
/**
* @author diecui1202 on 15/11/24.
* @author hengyunabc 2018-11-16
*/
@Name("jad")
@Summary("Decompile class")
@Description(Constants.EXAMPLE +
" jad java.lang.String\n" +
" jad java.lang.String toString\n" +
" jad java.lang.String -d /tmp/jad/dump\n" +
" jad --source-only java.lang.String\n" +
" jad -c 39eb305e org/apache/log4j/Logger\n" +
" jad -c 39eb305e -E org\\\\.apache\\\\.*\\\\.StringUtils\n" +
Constants.WIKI + Constants.WIKI_HOME + "jad")
public class JadCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(JadCommand.class);
private static Pattern pattern = Pattern.compile("(?m)^/\\*\\s*\\*/\\s*$" + System.getProperty("line.separator"));
private String classPattern;
private String methodName;
private String code = null;
private String classLoaderClass;
private boolean isRegEx = false;
private boolean hideUnicode = false;
private boolean lineNumber;
private String directory;
/**
* jad output source code only
*/
private boolean sourceOnly = false;
@Argument(argName = "class-pattern", index = 0)
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = StringUtils.normalizeClassName(classPattern);
}
@Argument(argName = "method-name", index = 1, required = false)
@Description("Method name pattern, decompile a specific method instead of the whole class")
public void setMethodName(String methodName) {
this.methodName = methodName;
}
@Option(shortName = "c", longName = "code")
@Description("The hash code of the special class's classLoader")
public void setCode(String code) {
this.code = code;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(longName = "hideUnicode", flag = true)
@Description("Hide unicode, default value false")
public void setHideUnicode(boolean hideUnicode) {
this.hideUnicode = hideUnicode;
}
@Option(longName = "source-only", flag = true)
@Description("Output source code only")
public void setSourceOnly(boolean sourceOnly) {
this.sourceOnly = sourceOnly;
}
@Option(longName = "lineNumber")
@DefaultValue("true")
@Description("Output source code contains line number, default value true")
public void setLineNumber(boolean lineNumber) {
this.lineNumber = lineNumber;
}
@Option(shortName = "d", longName = "directory")
@Description("Sets the destination directory for dumped class files required by cfr decompiler")
public void setDirectory(String directory) {
this.directory = directory;
}
@Override
public void process(CommandProcess process) {
if (directory != null && !FileUtils.isDirectoryOrNotExist(directory)) {
process.end(-1, directory + " :is not a directory, please check it");
return;
}
Instrumentation inst = process.session().getInstrumentation();
if (code == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
code = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
JadModel jadModel = new JadModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(jadModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
Set<Class<?>> matchedClasses = SearchUtils.searchClassOnly(inst, classPattern, isRegEx, code);
try {
final RowAffect affect = new RowAffect();
final ExitStatus status;
if (matchedClasses == null || matchedClasses.isEmpty()) {
status = processNoMatch(process);
} else if (matchedClasses.size() > 1) {
status = processMatches(process, matchedClasses);
} else { // matchedClasses size is 1
// find inner classes.
Set<Class<?>> withInnerClasses = SearchUtils.searchClassOnly(inst, matchedClasses.iterator().next().getName() + "$*", false, code);
if(withInnerClasses.isEmpty()) {
withInnerClasses = matchedClasses;
}
status = processExactMatch(process, affect, inst, matchedClasses, withInnerClasses);
}
if (!this.sourceOnly) {
process.appendResult(new RowAffectModel(affect));
}
CommandUtils.end(process, status);
} catch (Throwable e){
logger.error("processing error", e);
process.end(-1, "processing error");
}
}
private ExitStatus processExactMatch(CommandProcess process, RowAffect affect, Instrumentation inst, Set<Class<?>> matchedClasses, Set<Class<?>> withInnerClasses) {
Class<?> c = matchedClasses.iterator().next();
Set<Class<?>> allClasses = new HashSet<>(withInnerClasses);
allClasses.add(c);
try {
final ClassDumpTransformer transformer;
if (directory == null) {
transformer = new ClassDumpTransformer(allClasses);
} else {
transformer = new ClassDumpTransformer(allClasses, new File(directory));
}
InstrumentationUtils.retransformClasses(inst, transformer, allClasses);
Map<Class<?>, File> classFiles = transformer.getDumpResult();
if (classFiles == null || classFiles.isEmpty()) {
return ExitStatus.failure(-1, "jad: fail to dump class file for decompiler, make sure you have write permission of the directory \"" + transformer.dumpDir() +
"\" or try with \"-d/--directory\" to specify the directory of dump files");
}
File classFile = classFiles.get(c);
Pair<String,NavigableMap<Integer,Integer>> decompileResult = Decompiler.decompileWithMappings(classFile.getAbsolutePath(), methodName, hideUnicode, lineNumber);
String source = decompileResult.getFirst();
if (source != null) {
source = pattern.matcher(source).replaceAll("");
} else {
source = "unknown";
}
JadModel jadModel = new JadModel();
jadModel.setSource(source);
jadModel.setMappings(decompileResult.getSecond());
if (!this.sourceOnly) {
jadModel.setClassInfo(ClassUtils.createSimpleClassInfo(c));
jadModel.setLocation(ClassUtils.getCodeSource(c.getProtectionDomain().getCodeSource()));
}
process.appendResult(jadModel);
affect.rCnt(classFiles.keySet().size());
return ExitStatus.success();
} catch (Throwable t) {
logger.error("jad: fail to decompile class: " + c.getName(), t);
return ExitStatus.failure(-1, "jad: fail to decompile class: " + c.getName() + ", please check $HOME/logs/arthas/arthas.log for more details.");
}
}
private ExitStatus processMatches(CommandProcess process, Set<Class<?>> matchedClasses) {
String usage = "jad -c <hashcode> " + classPattern;
String msg = " Found more than one class for: " + classPattern + ", Please use " + usage;
process.appendResult(new MessageModel(msg));
List<ClassVO> classVOs = ClassUtils.createClassVOList(matchedClasses);
JadModel jadModel = new JadModel();
jadModel.setMatchedClasses(classVOs);
process.appendResult(jadModel);
return ExitStatus.failure(-1, msg);
}
private ExitStatus processNoMatch(CommandProcess process) {
return ExitStatus.failure(-1, "No class found for: " + classPattern);
}
@Override
public void complete(Completion completion) {
int argumentIndex = CompletionUtils.detectArgumentIndex(completion);
if (argumentIndex == 1) {
if (!CompletionUtils.completeClassName(completion)) {
super.complete(completion);
}
return;
} else if (argumentIndex == 2) {
if (!CompletionUtils.completeMethodName(completion)) {
super.complete(completion);
}
return;
}
super.complete(completion);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/RetransformCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/RetransformCommand.java | package com.taobao.arthas.core.command.klass100;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.taobao.arthas.core.advisor.TransformerManager;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.RetransformModel;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
*
* Retransform Classes.
*
* @author hengyunabc 2021-01-05
* @see java.lang.instrument.Instrumentation#retransformClasses(Class...)
*/
@Name("retransform")
@Summary("Retransform classes. @see Instrumentation#retransformClasses(Class...)")
@Description(Constants.EXAMPLE + " retransform /tmp/Test.class\n"
+ " retransform -l \n"
+ " retransform -d 1 # delete retransform entry\n"
+ " retransform --deleteAll # delete all retransform entries\n"
+ " retransform --classPattern demo.* # triger retransform classes\n"
+ " retransform -c 327a647b /tmp/Test.class /tmp/Test\\$Inner.class \n"
+ " retransform --classLoaderClass 'sun.misc.Launcher$AppClassLoader' /tmp/Test.class\n"
+ Constants.WIKI + Constants.WIKI_HOME
+ "retransform")
public class RetransformCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(RetransformCommand.class);
private static final int MAX_FILE_SIZE = 10 * 1024 * 1024;
private static volatile List<RetransformEntry> retransformEntries = new ArrayList<RetransformEntry>();
private static volatile ClassFileTransformer transformer = null;
private String hashCode;
private String classLoaderClass;
private List<String> paths;
private boolean list;
private int delete = -1;
private boolean deleteAll;
private String classPattern;
private int limit;
@Option(shortName = "l", longName = "list", flag = true)
@Description("list all retransform entry.")
public void setList(boolean list) {
this.list = list;
}
@Option(shortName = "d", longName = "delete")
@Description("delete retransform entry by id.")
public void setDelete(int delete) {
this.delete = delete;
}
@Option(longName = "deleteAll", flag = true)
@Description("delete all retransform entries.")
public void setDeleteAll(boolean deleteAll) {
this.deleteAll = deleteAll;
}
@Option(longName = "classPattern")
@Description("trigger retransform matched classes by class pattern.")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Option(shortName = "c", longName = "classloader")
@Description("classLoader hashcode")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Argument(argName = "classfilePaths", index = 0, required = false)
@Description(".class file paths")
public void setPaths(List<String> paths) {
this.paths = paths;
}
@Option(longName = "limit")
@Description("The limit of dump classes size, default value is 50")
@DefaultValue("50")
public void setLimit(int limit) {
this.limit = limit;
}
private static void initTransformer() {
if (transformer != null) {
return;
} else {
synchronized (RetransformCommand.class) {
if (transformer == null) {
transformer = new RetransformClassFileTransformer();
TransformerManager transformerManager = ArthasBootstrap.getInstance().getTransformerManager();
transformerManager.addRetransformer(transformer);
}
}
}
}
@Override
public void process(CommandProcess process) {
initTransformer();
RetransformModel retransformModel = new RetransformModel();
Instrumentation inst = process.session().getInstrumentation();
if (this.list) {
List<RetransformEntry> retransformEntryList = allRetransformEntries();
retransformModel.setRetransformEntries(retransformEntryList);
process.appendResult(retransformModel);
process.end();
return;
} else if (this.deleteAll) {
deleteAllRetransformEntry();
process.appendResult(retransformModel);
process.end();
return;
} else if (this.delete > 0) {
deleteRetransformEntry(this.delete);
process.end();
return;
} else if (this.classPattern != null) {
Set<Class<?>> searchClass = SearchUtils.searchClass(inst, classPattern, false, this.hashCode);
if (searchClass.isEmpty()) {
process.end(-1, "These classes are not found in the JVM and may not be loaded: " + classPattern);
return;
}
if (searchClass.size() > limit) {
process.end(-1, "match classes size: " + searchClass.size() + ", more than limit: " + limit
+ ", It is recommended to use a more precise class pattern.");
}
try {
inst.retransformClasses(searchClass.toArray(new Class[0]));
for (Class<?> clazz : searchClass) {
retransformModel.addRetransformClass(clazz.getName());
}
process.appendResult(retransformModel);
process.end();
return;
} catch (Throwable e) {
String message = "retransform error! " + e.toString();
logger.error(message, e);
process.end(-1, message);
return;
}
}
for (String path : paths) {
File file = new File(path);
if (!file.exists()) {
process.end(-1, "file does not exist, path:" + path);
return;
}
if (!file.isFile()) {
process.end(-1, "not a normal file, path:" + path);
return;
}
if (file.length() >= MAX_FILE_SIZE) {
process.end(-1, "file size: " + file.length() + " >= " + MAX_FILE_SIZE + ", path: " + path);
return;
}
}
Map<String, byte[]> bytesMap = new HashMap<String, byte[]>();
for (String path : paths) {
RandomAccessFile f = null;
try {
f = new RandomAccessFile(path, "r");
final byte[] bytes = new byte[(int) f.length()];
f.readFully(bytes);
final String clazzName = readClassName(bytes);
bytesMap.put(clazzName, bytes);
} catch (Exception e) {
logger.warn("load class file failed: " + path, e);
process.end(-1, "load class file failed: " + path + ", error: " + e);
return;
} finally {
if (f != null) {
try {
f.close();
} catch (IOException e) {
// ignore
}
}
}
}
if (bytesMap.size() != paths.size()) {
process.end(-1, "paths may contains same class name!");
return;
}
List<RetransformEntry> retransformEntryList = new ArrayList<RetransformEntry>();
List<Class<?>> classList = new ArrayList<Class<?>>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if (bytesMap.containsKey(clazz.getName())) {
if (hashCode == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst,
classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils
.createClassLoaderVOList(matchedClassLoaders);
retransformModel.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(retransformModel);
process.end(-1,
"Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader != null && hashCode != null
&& !Integer.toHexString(classLoader.hashCode()).equals(hashCode)) {
continue;
}
RetransformEntry retransformEntry = new RetransformEntry(clazz.getName(), bytesMap.get(clazz.getName()),
hashCode, classLoaderClass);
retransformEntryList.add(retransformEntry);
classList.add(clazz);
retransformModel.addRetransformClass(clazz.getName());
logger.info("Try retransform class name: {}, ClassLoader: {}", clazz.getName(), clazz.getClassLoader());
}
}
try {
if (retransformEntryList.isEmpty()) {
process.end(-1, "These classes are not found in the JVM and may not be loaded: " + bytesMap.keySet());
return;
}
addRetransformEntry(retransformEntryList);
inst.retransformClasses(classList.toArray(new Class[0]));
process.appendResult(retransformModel);
process.end();
} catch (Throwable e) {
String message = "retransform error! " + e.toString();
logger.error(message, e);
process.end(-1, message);
}
}
private static String readClassName(final byte[] bytes) {
return new ClassReader(bytes).getClassName().replace('/', '.');
}
@Override
public void complete(Completion completion) {
List<CliToken> tokens = completion.lineTokens();
if (CompletionUtils.shouldCompleteOption(completion, "--classPattern")) {
CompletionUtils.completeClassName(completion);
return;
}
for (CliToken token : tokens) {
String tokenStr = token.value();
if (tokenStr != null && tokenStr.startsWith("-")) {
super.complete(completion);
return;
}
}
// 最后，没有有 - 开头的，才尝试补全 file path
if (!CompletionUtils.completeFilePath(completion)) {
super.complete(completion);
}
}
public static class RetransformEntry {
private static final AtomicInteger counter = new AtomicInteger(0);
private int id;
private String className;
private byte[] bytes;
private String hashCode;
private String classLoaderClass;
/**
* 被 transform 触发次数
*/
private int transformCount = 0;
public RetransformEntry(String className, byte[] bytes, String hashCode, String classLoaderClass) {
id = counter.incrementAndGet();
this.className = className;
this.bytes = bytes;
this.hashCode = hashCode;
this.classLoaderClass = classLoaderClass;
}
public void incTransformCount() {
transformCount++;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getTransformCount() {
return transformCount;
}
public void setTransformCount(int transformCount) {
this.transformCount = transformCount;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public byte[] getBytes() {
return bytes;
}
public void setBytes(byte[] bytes) {
this.bytes = bytes;
}
public String getHashCode() {
return hashCode;
}
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
}
public static synchronized void addRetransformEntry(List<RetransformEntry> retransformEntryList) {
List<RetransformEntry> tmp = new ArrayList<RetransformEntry>();
tmp.addAll(retransformEntries);
tmp.addAll(retransformEntryList);
Collections.sort(tmp, new Comparator<RetransformEntry>() {
@Override
public int compare(RetransformEntry entry1, RetransformEntry entry2) {
return Integer.compare(entry1.getId(), entry2.getId());
}
});
retransformEntries = tmp;
}
public static synchronized RetransformEntry deleteRetransformEntry(int id) {
RetransformEntry result = null;
List<RetransformEntry> tmp = new ArrayList<RetransformEntry>();
for (RetransformEntry entry : retransformEntries) {
if (entry.getId() != id) {
tmp.add(entry);
} else {
result = entry;
}
}
retransformEntries = tmp;
return result;
}
public static List<RetransformEntry> allRetransformEntries() {
return retransformEntries;
}
public static synchronized void deleteAllRetransformEntry() {
retransformEntries = new ArrayList<RetransformEntry>();
}
static class RetransformClassFileTransformer implements ClassFileTransformer {
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
if (className == null) {
return null;
}
className = className.replace('/', '.');
List<RetransformEntry> allRetransformEntries = allRetransformEntries();
// 倒序，因为要执行的配置生效
ListIterator<RetransformEntry> listIterator = allRetransformEntries
.listIterator(allRetransformEntries.size());
while (listIterator.hasPrevious()) {
RetransformEntry retransformEntry = listIterator.previous();
int id = retransformEntry.getId();
// 判断类名是否一致
boolean updateFlag = false;
// 类名一致，则看是否要比较 loader，如果不需要比较 loader，则认为成功
if (className.equals(retransformEntry.getClassName())) {
if (retransformEntry.getClassLoaderClass() != null || retransformEntry.getHashCode() != null) {
updateFlag = isLoaderMatch(retransformEntry, loader);
} else {
updateFlag = true;
}
}
if (updateFlag) {
logger.info("RetransformCommand match class: {}, id: {}, classLoaderClass: {}, hashCode: {}",
className, id, retransformEntry.getClassLoaderClass(), retransformEntry.getHashCode());
retransformEntry.incTransformCount();
return retransformEntry.getBytes();
}
}
return null;
}
private boolean isLoaderMatch(RetransformEntry retransformEntry, ClassLoader loader) {
if (loader == null) {
return false;
}
if (retransformEntry.getClassLoaderClass() != null) {
if (loader.getClass().getName().equals(retransformEntry.getClassLoaderClass())) {
return true;
}
}
if (retransformEntry.getHashCode() != null) {
String hashCode = Integer.toHexString(loader.hashCode());
if (hashCode.equals(retransformEntry.getHashCode())) {
return true;
}
}
return false;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/ClassDumpTransformer.java | core/src/main/java/com/taobao/arthas/core/command/klass100/ClassDumpTransformer.java | package com.taobao.arthas.core.command.klass100;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.util.FileUtils;
import com.taobao.arthas.core.util.LogUtil;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author beiwei30 on 25/11/2016.
*/
class ClassDumpTransformer implements ClassFileTransformer {
private static final Logger logger = LoggerFactory.getLogger(ClassDumpTransformer.class);
private Set<Class<?>> classesToEnhance;
private Map<Class<?>, File> dumpResult;
private File arthasLogHome;
private File directory;
public ClassDumpTransformer(Set<Class<?>> classesToEnhance) {
this(classesToEnhance, null);
}
public ClassDumpTransformer(Set<Class<?>> classesToEnhance, File directory) {
this.classesToEnhance = classesToEnhance;
this.dumpResult = new HashMap<Class<?>, File>();
this.arthasLogHome = new File(LogUtil.loggingDir());
this.directory = directory;
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer)
throws IllegalClassFormatException {
if (classesToEnhance.contains(classBeingRedefined)) {
dumpClassIfNecessary(classBeingRedefined, classfileBuffer);
}
return null;
}
public Map<Class<?>, File> getDumpResult() {
return dumpResult;
}
public File dumpDir() {
String classDumpDir = "classdump";
final File dumpDir;
if (directory != null) {
dumpDir = directory;
} else {
dumpDir = new File(arthasLogHome, classDumpDir);
}
return dumpDir;
}
private void dumpClassIfNecessary(Class<?> clazz, byte[] data) {
String className = clazz.getName();
ClassLoader classLoader = clazz.getClassLoader();
// 创建类所在的包路径
File dumpDir = dumpDir();
if (!dumpDir.mkdirs() && !dumpDir.exists()) {
logger.warn("create dump directory:{} failed.", dumpDir.getAbsolutePath());
return;
}
String fileName;
if (classLoader != null) {
fileName = classLoader.getClass().getName() + "-" + Integer.toHexString(classLoader.hashCode()) +
File.separator + className.replace(".", File.separator) + ".class";
} else {
fileName = className.replace(".", File.separator) + ".class";
}
File dumpClassFile = new File(dumpDir, fileName);
// 将类字节码写入文件
try {
FileUtils.writeByteArrayToFile(dumpClassFile, data);
dumpResult.put(clazz, dumpClassFile);
} catch (IOException e) {
logger.warn("dump class:{} to file {} failed.", className, dumpClassFile, e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/SearchMethodCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/SearchMethodCommand.java | package com.taobao.arthas.core.command.klass100;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Set;
import java.util.Collection;
import java.util.List;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.SearchMethodModel;
import com.taobao.arthas.core.command.model.MethodVO;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.util.matcher.RegexMatcher;
import com.taobao.arthas.core.util.matcher.WildcardMatcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* 展示方法信息
*
* @author vlinux
* @author hengyunabc 2019-02-13
*/
@Name("sm")
@Summary("Search the method of classes loaded by JVM")
@Description(Constants.EXAMPLE +
" sm java.lang.String\n" +
" sm -d org.apache.commons.lang.StringUtils\n" +
" sm -d org/apache/commons/lang/StringUtils\n" +
" sm *StringUtils *\n" +
" sm -Ed org\\\\.apache\\\\.commons\\\\.lang\\.StringUtils .*\n" +
Constants.WIKI + Constants.WIKI_HOME + "sm")
public class SearchMethodCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(SearchMethodCommand.class);
private String classPattern;
private String methodPattern;
private String hashCode = null;
private String classLoaderClass;
private boolean isDetail = false;
private boolean isRegEx = false;
private int numberOfLimit = 100;
@Argument(argName = "class-pattern", index = 0)
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Argument(argName = "method-pattern", index = 1, required = false)
@Description("Method name pattern")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Option(shortName = "d", longName = "details", flag = true)
@Description("Display the details of method")
public void setDetail(boolean detail) {
isDetail = detail;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special class's classLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "n", longName = "limits")
@Description("Maximum number of matching classes (100 by default)")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
@Override
public void process(CommandProcess process) {
RowAffect affect = new RowAffect();
Instrumentation inst = process.session().getInstrumentation();
Matcher<String> methodNameMatcher = methodNameMatcher();
if (hashCode == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
SearchMethodModel searchmethodModel = new SearchMethodModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(searchmethodModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
Set<Class<?>> matchedClasses = SearchUtils.searchClass(inst, classPattern, isRegEx, hashCode);
if (numberOfLimit > 0 && matchedClasses.size() > numberOfLimit) {
process.end(-1, "The number of matching classes is greater than : " + numberOfLimit+". \n" +
"Please specify a more accurate 'class-patten' or use the parameter '-n' to change the maximum number of matching classes.");
return;
}
for (Class<?> clazz : matchedClasses) {
try {
for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
if (!methodNameMatcher.matching("<init>")) {
continue;
}
MethodVO methodInfo = ClassUtils.createMethodInfo(constructor, clazz, isDetail);
process.appendResult(new SearchMethodModel(methodInfo, isDetail));
affect.rCnt(1);
}
for (Method method : clazz.getDeclaredMethods()) {
if (!methodNameMatcher.matching(method.getName())) {
continue;
}
MethodVO methodInfo = ClassUtils.createMethodInfo(method, clazz, isDetail);
process.appendResult(new SearchMethodModel(methodInfo, isDetail));
affect.rCnt(1);
}
} catch (Error e) {
//print failed className
String msg = String.format("process class failed: %s, error: %s", clazz.getName(), e.toString());
logger.error(msg, e);
process.end(1, msg);
return;
}
}
process.appendResult(new RowAffectModel(affect));
process.end();
}
private Matcher<String> methodNameMatcher() {
// auto fix default methodPattern
if (StringUtils.isBlank(methodPattern)) {
methodPattern = isRegEx ? ".*" : "*";
}
return isRegEx ? new RegexMatcher(methodPattern) : new WildcardMatcher(methodPattern);
}
@Override
public void complete(Completion completion) {
int argumentIndex = CompletionUtils.detectArgumentIndex(completion);
if (argumentIndex == 1) {
if (!CompletionUtils.completeClassName(completion)) {
super.complete(completion);
}
return;
} else if (argumentIndex == 2) {
if (!CompletionUtils.completeMethodName(completion)) {
super.complete(completion);
}
return;
}
super.complete(completion);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/OgnlCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/OgnlCommand.java | package com.taobao.arthas.core.command.klass100;
import java.lang.instrument.Instrumentation;
import java.util.Collection;
import java.util.List;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.express.Express;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.command.model.OgnlModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
*
* @author hengyunabc 2018-10-18
*
*/
@Name("ognl")
@Summary("Execute ognl expression.")
@Description(Constants.EXAMPLE
+ " ognl '@java.lang.System@out.println(\"hello \\u4e2d\\u6587\")' \n"
+ " ognl -x 2 '@Singleton@getInstance()' \n"
+ " ognl '@Demo@staticFiled' \n"
+ " ognl '#value1=@System@getProperty(\"java.home\"), #value2=@System@getProperty(\"java.runtime.name\"), {#value1, #value2}'\n"
+ " ognl -c 5d113a51 '@com.taobao.arthas.core.GlobalOptions@isDump' \n"
+ Constants.WIKI + Constants.WIKI_HOME + "ognl\n"
+ " https://commons.apache.org/proper/commons-ognl/language-guide.html")
public class OgnlCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(OgnlCommand.class);
private String express;
private String hashCode;
private String classLoaderClass;
private int expand = 1;
@Argument(argName = "express", index = 0, required = true)
@Description("The ognl expression.")
public void setExpress(String express) {
this.express = express;
}
@Option(shortName = "c", longName = "classLoader")
@Description("The hash code of the special class's classLoader, default classLoader is SystemClassLoader.")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (1 by default).")
public void setExpand(Integer expand) {
this.expand = expand;
}
@Override
public void process(CommandProcess process) {
Instrumentation inst = process.session().getInstrumentation();
ClassLoader classLoader = null;
if (hashCode != null) {
classLoader = ClassLoaderUtils.getClassLoader(inst, hashCode);
if (classLoader == null) {
process.end(-1, "Can not find classloader with hashCode: " + hashCode + ".");
return;
}
} else if (classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
classLoader = matchedClassLoaders.get(0);
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
OgnlModel ognlModel = new OgnlModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(ognlModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
} else {
classLoader = ClassLoader.getSystemClassLoader();
}
Express unpooledExpress = ExpressFactory.unpooledExpress(classLoader);
try {
// https://github.com/alibaba/arthas/issues/2892
Object value = unpooledExpress.bind(new Object()).get(express);
OgnlModel ognlModel = new OgnlModel()
.setValue(new ObjectVO(value, expand));
process.appendResult(ognlModel);
process.end();
} catch (ExpressException e) {
logger.warn("ognl: failed execute express: " + express, e);
process.end(-1, "Failed to execute ognl, exception message: " + e.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details. ");
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/GetStaticCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/GetStaticCommand.java | package com.taobao.arthas.core.command.klass100;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.command.model.ClassVO;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.GetStaticModel;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.ExitStatus;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.CommandUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.util.matcher.RegexMatcher;
import com.taobao.arthas.core.util.matcher.WildcardMatcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.List;
import java.util.Set;
import java.util.Collection;
/**
* @author diecui1202 on 2017/9/27.
*/
@Name("getstatic")
@Summary("Show the static field of a class")
@Description(Constants.EXAMPLE +
" getstatic demo.MathGame random\n" +
" getstatic -c 39eb305e org.apache.log4j.LogManager DEFAULT_CONFIGURATION_FILE\n" +
Constants.WIKI + Constants.WIKI_HOME + "getstatic")
public class GetStaticCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(GetStaticCommand.class);
private String classPattern;
private String fieldPattern;
private String express;
private String hashCode = null;
private String classLoaderClass;
private boolean isRegEx = false;
private int expand = 1;
@Argument(argName = "class-pattern", index = 0)
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Argument(argName = "field-pattern", index = 1)
@Description("Field name pattern")
public void setFieldPattern(String fieldPattern) {
this.fieldPattern = fieldPattern;
}
@Argument(argName = "express", index = 2, required = false)
@Description("the content you want to watch, written by ognl")
public void setExpress(String express) {
this.express = express;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special class's classLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (1 by default)")
public void setExpand(Integer expand) {
this.expand = expand;
}
@Override
public void process(CommandProcess process) {
RowAffect affect = new RowAffect();
Instrumentation inst = process.session().getInstrumentation();
if (hashCode == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
GetStaticModel getStaticModel = new GetStaticModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(getStaticModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
Set<Class<?>> matchedClasses = SearchUtils.searchClassOnly(inst, classPattern, isRegEx, hashCode);
try {
if (matchedClasses == null || matchedClasses.isEmpty()) {
process.end(-1, "No class found for: " + classPattern);
return;
}
ExitStatus status = null;
if (matchedClasses.size() > 1) {
status = processMatches(process, matchedClasses);
} else {
status = processExactMatch(process, affect, inst, matchedClasses);
}
process.appendResult(new RowAffectModel(affect));
CommandUtils.end(process, status);
} catch (Throwable e){
logger.error("processing error", e);
process.appendResult(new RowAffectModel(affect));
process.end(-1, "processing error");
}
}
private ExitStatus processExactMatch(CommandProcess process, RowAffect affect, Instrumentation inst,
Set<Class<?>> matchedClasses) {
Matcher<String> fieldNameMatcher = fieldNameMatcher();
Class<?> clazz = matchedClasses.iterator().next();
boolean found = false;
for (Field field : clazz.getDeclaredFields()) {
if (!Modifier.isStatic(field.getModifiers()) || !fieldNameMatcher.matching(field.getName())) {
continue;
}
if (!field.isAccessible()) {
field.setAccessible(true);
}
try {
Object value = field.get(null);
if (!StringUtils.isEmpty(express)) {
value = ExpressFactory.threadLocalExpress(value).get(express);
}
process.appendResult(new GetStaticModel(field.getName(), value, expand));
affect.rCnt(1);
} catch (IllegalAccessException e) {
logger.warn("getstatic: failed to get static value, class: {}, field: {} ", clazz, field.getName(), e);
process.appendResult(new MessageModel("Failed to get static, exception message: " + e.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details. "));
} catch (ExpressException e) {
logger.warn("getstatic: failed to get express value, class: {}, field: {}, express: {}", clazz, field.getName(), express, e);
process.appendResult(new MessageModel("Failed to get static, exception message: " + e.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details. "));
} finally {
found = true;
}
}
if (!found) {
return ExitStatus.failure(-1, "getstatic: no matched static field was found");
} else {
return ExitStatus.success();
}
}
private ExitStatus processMatches(CommandProcess process, Set<Class<?>> matchedClasses) {
// Element usage = new LabelElement("getstatic -c <hashcode> " + classPattern + " " + fieldPattern).style(
// Decoration.bold.fg(Color.blue));
// process.write("\n Found more than one class for: " + classPattern + ", Please use " + RenderUtil.render(usage, process.width()));
//TODO support message style
String usage = "getstatic -c <hashcode> " + classPattern + " " + fieldPattern;
process.appendResult(new MessageModel("Found more than one class for: " + classPattern + ", Please use: "+usage));
List<ClassVO> matchedClassVOs = ClassUtils.createClassVOList(matchedClasses);
process.appendResult(new GetStaticModel(matchedClassVOs));
return ExitStatus.failure(-1, "Found more than one class for: " + classPattern + ", Please use: "+usage);
}
private Matcher<String> fieldNameMatcher() {
return isRegEx ? new RegexMatcher(fieldPattern) : new WildcardMatcher(fieldPattern);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/klass100/DumpClassCommand.java | core/src/main/java/com/taobao/arthas/core/command/klass100/DumpClassCommand.java | package com.taobao.arthas.core.command.klass100;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ClassVO;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.DumpClassModel;
import com.taobao.arthas.core.command.model.DumpClassVO;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.RowAffectModel;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.ExitStatus;
import com.taobao.arthas.core.util.*;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.io.File;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Collection;
/**
* Dump class byte array
*/
@Name("dump")
@Summary("Dump class byte array from JVM")
@Description(Constants.EXAMPLE +
" dump java.lang.String\n" +
" dump -d /tmp/output java.lang.String\n" +
" dump org/apache/commons/lang/StringUtils\n" +
" dump *StringUtils\n" +
" dump -E org\\\\.apache\\\\.commons\\\\.lang\\\\.StringUtils\n" +
Constants.WIKI + Constants.WIKI_HOME + "dump")
public class DumpClassCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(DumpClassCommand.class);
private String classPattern;
private String code = null;
private String classLoaderClass;
private boolean isRegEx = false;
private String directory;
private int limit;
@Argument(index = 0, argName = "class-pattern")
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Option(shortName = "c", longName = "code")
@Description("The hash code of the special class's classLoader")
public void setCode(String code) {
this.code = code;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "d", longName = "directory")
@Description("Sets the destination directory for class files")
public void setDirectory(String directory) {
this.directory = directory;
}
@Option(shortName = "l", longName = "limit")
@Description("The limit of dump classes size, default value is 50")
@DefaultValue("50")
public void setLimit(int limit) {
this.limit = limit;
}
@Override
public void process(CommandProcess process) {
try {
if (directory != null && !FileUtils.isDirectoryOrNotExist(directory)) {
process.end(-1, directory + " :is not a directory, please check it");
return;
}
Instrumentation inst = process.session().getInstrumentation();
if (code == null && classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
if (matchedClassLoaders.size() == 1) {
code = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
DumpClassModel dumpClassModel = new DumpClassModel()
.setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(dumpClassModel);
process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
Set<Class<?>> matchedClasses = SearchUtils.searchClass(inst, classPattern, isRegEx, code);
final RowAffect effect = new RowAffect();
final ExitStatus status;
if (matchedClasses == null || matchedClasses.isEmpty()) {
status = processNoMatch(process);
} else if (matchedClasses.size() > limit) {
status = processMatches(process, matchedClasses);
} else {
status = processMatch(process, effect, inst, matchedClasses);
}
process.appendResult(new RowAffectModel(effect));
CommandUtils.end(process, status);
} catch (Throwable e){
logger.error("processing error", e);
process.end(-1, "processing error");
}
}
@Override
public void complete(Completion completion) {
if (!CompletionUtils.completeClassName(completion)) {
super.complete(completion);
}
}
private ExitStatus processMatch(CommandProcess process, RowAffect effect, Instrumentation inst, Set<Class<?>> matchedClasses) {
try {
Map<Class<?>, File> classFiles = dump(inst, matchedClasses);
List<DumpClassVO> dumpedClasses = new ArrayList<DumpClassVO>(classFiles.size());
for (Map.Entry<Class<?>, File> entry : classFiles.entrySet()) {
Class<?> clazz = entry.getKey();
File file = entry.getValue();
DumpClassVO dumpClassVO = new DumpClassVO();
dumpClassVO.setLocation(file.getCanonicalPath());
ClassUtils.fillSimpleClassVO(clazz, dumpClassVO);
dumpedClasses.add(dumpClassVO);
}
process.appendResult(new DumpClassModel().setDumpedClasses(dumpedClasses));
effect.rCnt(classFiles.keySet().size());
return ExitStatus.success();
} catch (Throwable t) {
logger.error("dump: fail to dump classes: " + matchedClasses, t);
return ExitStatus.failure(-1, "dump: fail to dump classes: " + matchedClasses);
}
}
private ExitStatus processMatches(CommandProcess process, Set<Class<?>> matchedClasses) {
String msg = String.format(
"Found more than %d class for: %s, Please Try to specify the classloader with the -c option, or try to use --limit option.",
limit, classPattern);
process.appendResult(new MessageModel(msg));
List<ClassVO> classVOs = ClassUtils.createClassVOList(matchedClasses);
process.appendResult(new DumpClassModel().setMatchedClasses(classVOs));
return ExitStatus.failure(-1, msg);
}
private ExitStatus processNoMatch(CommandProcess process) {
return ExitStatus.failure(-1, "No class found for: " + classPattern);
}
private Map<Class<?>, File> dump(Instrumentation inst, Set<Class<?>> classes) throws UnmodifiableClassException {
ClassDumpTransformer transformer = null;
if (directory != null) {
transformer = new ClassDumpTransformer(classes, new File(directory));
} else {
transformer = new ClassDumpTransformer(classes);
}
InstrumentationUtils.retransformClasses(inst, transformer, classes);
return transformer.getDumpResult();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/Log4j2Helper.java | core/src/main/java/com/taobao/arthas/core/command/logger/Log4j2Helper.java | package com.taobao.arthas.core.command.logger;
import java.lang.reflect.Field;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.appender.AsyncAppender;
import org.apache.logging.log4j.core.appender.ConsoleAppender;
import org.apache.logging.log4j.core.appender.FileAppender;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.LoggerConfig;
/**
*
* @author hengyunabc 2019-09-20
*
*/
public class Log4j2Helper {
private static boolean Log4j2 = false;
private static Field configField = null;
static {
try {
Class<?> loggerClass = Log4j2Helper.class.getClassLoader().loadClass("org.apache.logging.log4j.Logger");
// 这里可能会加载到其它上游ClassLoader的log4j2，因此需要判断是否当前classloader
if (loggerClass.getClassLoader().equals(Log4j2Helper.class.getClassLoader())) {
Log4j2 = true;
}
try {
configField = LoggerConfig.class.getDeclaredField("config");
configField.setAccessible(true);
} catch (Throwable e) {
// ignore
}
} catch (Throwable t) {
}
}
public static boolean hasLength(String str) {
return (str != null && !str.isEmpty());
}
private static LoggerConfig getLoggerConfig(String name) {
if (!hasLength(name) || LoggerConfig.ROOT.equalsIgnoreCase(name)) {
name = LogManager.ROOT_LOGGER_NAME;
}
return getLoggerContext().getConfiguration().getLoggers().get(name);
}
private static LoggerContext getLoggerContext() {
return (LoggerContext) LogManager.getContext(false);
}
public static Boolean updateLevel(String loggerName, String logLevel) {
if (Log4j2) {
Level level = Level.getLevel(logLevel.toUpperCase());
if (level == null) {
return null;
}
LoggerConfig loggerConfig = getLoggerConfig(loggerName);
if (loggerConfig == null) {
loggerConfig = new LoggerConfig(loggerName, level, true);
getLoggerContext().getConfiguration().addLogger(loggerName, loggerConfig);
} else {
loggerConfig.setLevel(level);
}
getLoggerContext().updateLoggers();
return Boolean.TRUE;
}
return null;
}
public static Map<String, Map<String, Object>> getLoggers(String name, boolean includeNoAppender) {
Map<String, Map<String, Object>> loggerInfoMap = new HashMap<String, Map<String, Object>>();
if (!Log4j2) {
return loggerInfoMap;
}
Configuration configuration = getLoggerContext().getConfiguration();
if (name != null && !name.trim().isEmpty()) {
LoggerConfig loggerConfig = configuration.getLoggerConfig(name);
if (loggerConfig == null) {
return loggerInfoMap;
}
// 排掉非root时，获取到root的logger config
if (!name.equalsIgnoreCase(LoggerConfig.ROOT) && isEmpty(loggerConfig.getName())) {
return loggerInfoMap;
}
loggerInfoMap.put(name, doGetLoggerInfo(loggerConfig));
} else {
// 获取所有logger时，如果没有appender则忽略
Map<String, LoggerConfig> loggers = configuration.getLoggers();
if (loggers != null) {
for (Entry<String, LoggerConfig> entry : loggers.entrySet()) {
LoggerConfig loggerConfig = entry.getValue();
if (!includeNoAppender) {
if (!loggerConfig.getAppenders().isEmpty()) {
loggerInfoMap.put(entry.getKey(), doGetLoggerInfo(entry.getValue()));
}
} else {
loggerInfoMap.put(entry.getKey(), doGetLoggerInfo(entry.getValue()));
}
}
}
}
return loggerInfoMap;
}
private static Object getConfigField(LoggerConfig loggerConfig) {
try {
if (configField != null) {
return configField.get(loggerConfig);
}
} catch (Throwable e) {
// ignore
}
return null;
}
private static Map<String, Object> doGetLoggerInfo(LoggerConfig loggerConfig) {
Map<String, Object> info = new HashMap<String, Object>();
String name = loggerConfig.getName();
if (name == null || name.trim().isEmpty()) {
name = LoggerConfig.ROOT;
}
info.put(LoggerHelper.name, name);
info.put(LoggerHelper.clazz, loggerConfig.getClass());
CodeSource codeSource = loggerConfig.getClass().getProtectionDomain().getCodeSource();
if (codeSource != null) {
info.put(LoggerHelper.codeSource, codeSource.getLocation());
}
Object config = getConfigField(loggerConfig);
if (config != null) {
info.put(LoggerHelper.config, config);
}
info.put(LoggerHelper.additivity, loggerConfig.isAdditive());
Level level = loggerConfig.getLevel();
if (level != null) {
info.put(LoggerHelper.level, level.toString());
}
List<Map<String, Object>> result = doGetLoggerAppenders(loggerConfig);
info.put(LoggerHelper.appenders, result);
return info;
}
private static List<Map<String, Object>> doGetLoggerAppenders(LoggerConfig loggerConfig) {
List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
Map<String, Appender> appenders = loggerConfig.getAppenders();
for (Entry<String, Appender> entry : appenders.entrySet()) {
Map<String, Object> info = new HashMap<String, Object>();
Appender appender = entry.getValue();
info.put(LoggerHelper.name, appender.getName());
info.put(LoggerHelper.clazz, appender.getClass());
result.add(info);
if (appender instanceof FileAppender) {
info.put(LoggerHelper.file, ((FileAppender) appender).getFileName());
} else if (appender instanceof ConsoleAppender) {
info.put(LoggerHelper.target, ((ConsoleAppender) appender).getTarget());
} else if (appender instanceof AsyncAppender) {
AsyncAppender asyncAppender = ((AsyncAppender) appender);
String[] appenderRefStrings = asyncAppender.getAppenderRefStrings();
info.put(LoggerHelper.blocking, asyncAppender.isBlocking());
info.put(LoggerHelper.appenderRef, Arrays.asList(appenderRefStrings));
}
}
return result;
}
private static boolean isEmpty(Object str) {
return str == null || "".equals(str);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/LoggerCommand.java | core/src/main/java/com/taobao/arthas/core/command/logger/LoggerCommand.java | package com.taobao.arthas.core.command.logger;
import java.io.IOException;
import java.io.InputStream;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.IOUtils;
import com.taobao.arthas.common.ReflectUtils;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.LoggerModel;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* logger command
*
* @author hengyunabc 2019-09-04
*/
//@formatter:off
@Name("logger")
@Summary("Print logger info, and update the logger level")
@Description("\nExamples:\n"
+ " logger\n"
+ " logger -c 327a647b\n"
+ " logger -c 327a647b --name ROOT --level debug\n"
+ " logger --include-no-appender\n"
+ Constants.WIKI + Constants.WIKI_HOME + "logger")
//@formatter:on
public class LoggerCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(LoggerCommand.class);
private static byte[] LoggerHelperBytes;
private static byte[] Log4jHelperBytes;
private static byte[] LogbackHelperBytes;
private static byte[] Log4j2HelperBytes;
private static Map<Class<?>, byte[]> classToBytesMap = new HashMap<Class<?>, byte[]>();
private static String arthasClassLoaderHash = ClassLoaderUtils
.classLoaderHash(LoggerCommand.class.getClassLoader());
static {
LoggerHelperBytes = loadClassBytes(LoggerHelper.class);
Log4jHelperBytes = loadClassBytes(Log4jHelper.class);
LogbackHelperBytes = loadClassBytes(LogbackHelper.class);
Log4j2HelperBytes = loadClassBytes(Log4j2Helper.class);
classToBytesMap.put(LoggerHelper.class, LoggerHelperBytes);
classToBytesMap.put(Log4jHelper.class, Log4jHelperBytes);
classToBytesMap.put(LogbackHelper.class, LogbackHelperBytes);
classToBytesMap.put(Log4j2Helper.class, Log4j2HelperBytes);
}
private String name;
private String hashCode;
private String classLoaderClass;
private String level;
/**
* include the loggers which don't have appenders, default false.
*/
private boolean includeNoAppender;
@Option(shortName = "n", longName = "name")
@Description("logger name")
public void setName(String name) {
this.name = name;
}
@Option(shortName = "c", longName = "classloader")
@Description("classLoader hashcode, if no value is set, default value is SystemClassLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "l", longName = "level")
@Description("set logger level")
public void setLevel(String level) {
this.level = level;
}
@Option(longName = "include-no-appender", flag = true)
@Description("include the loggers which don't have appenders, default value false")
public void setHaveAppender(boolean includeNoAppender) {
this.includeNoAppender = includeNoAppender;
}
@Override
public void process(CommandProcess process) {
// 所有代码都用 hashCode 来定位classloader，如果有指定 classLoaderClass，则尝试用 classLoaderClass 找到对应 classloader 的 hashCode
if (hashCode == null && classLoaderClass != null) {
Instrumentation inst = process.session().getInstrumentation();
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst,
classLoaderClass);
if (matchedClassLoaders.size() == 1) {
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils
.createClassLoaderVOList(matchedClassLoaders);
LoggerModel loggerModel = new LoggerModel().setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(loggerModel);
process.end(-1,
"Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}
// 每个分支中调用process.end()结束执行
if (this.name != null && this.level != null) {
level(process);
} else {
loggers(process);
}
}
public void level(CommandProcess process) {
Instrumentation inst = process.session().getInstrumentation();
boolean result = false;
// 如果不指定 classloader，则默认用 SystemClassLoader
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
if (hashCode != null) {
classLoader = ClassLoaderUtils.getClassLoader(inst, hashCode);
if (classLoader == null) {
process.end(-1, "Can not find classloader by hashCode: " + hashCode + ".");
return;
}
}
LoggerTypes loggerTypes = findLoggerTypes(process.session().getInstrumentation(), classLoader);
if (loggerTypes.contains(LoggerType.LOG4J)) {
try {
Boolean updateResult = this.updateLevel(inst, classLoader, Log4jHelper.class);
if (Boolean.TRUE.equals(updateResult)) {
result = true;
}
} catch (Throwable e) {
logger.error("logger command update log4j level error", e);
}
}
if (loggerTypes.contains(LoggerType.LOGBACK)) {
try {
Boolean updateResult = this.updateLevel(inst, classLoader, LogbackHelper.class);
if (Boolean.TRUE.equals(updateResult)) {
result = true;
}
} catch (Throwable e) {
logger.error("logger command update logback level error", e);
}
}
if (loggerTypes.contains(LoggerType.LOG4J2)) {
try {
Boolean updateResult = this.updateLevel(inst, classLoader, Log4j2Helper.class);
if (Boolean.TRUE.equals(updateResult)) {
result = true;
}
} catch (Throwable e) {
logger.error("logger command update log4j2 level error", e);
}
}
if (result) {
process.end(0, "Update logger level success.");
} else {
process.end(-1,
"Update logger level fail. Try to specify the classloader with the -c option. Use `sc -d CLASSNAME` to find out the classloader hashcode.");
}
}
public void loggers(CommandProcess process) {
Map<ClassLoader, LoggerTypes> classLoaderLoggerMap = new LinkedHashMap<ClassLoader, LoggerTypes>();
// 如果不指定 classloader，则打印所有 classloader 里的 logger 信息
for (Class<?> clazz : process.session().getInstrumentation().getAllLoadedClasses()) {
String className = clazz.getName();
ClassLoader classLoader = clazz.getClassLoader();
// if special classloader
if (this.hashCode != null && !this.hashCode.equals(StringUtils.classLoaderHash(clazz))) {
continue;
}
if (classLoader != null) {
LoggerTypes loggerTypes = classLoaderLoggerMap.get(classLoader);
if (loggerTypes == null) {
loggerTypes = new LoggerTypes();
classLoaderLoggerMap.put(classLoader, loggerTypes);
}
updateLoggerType(loggerTypes, classLoader, className);
}
}
for (Entry<ClassLoader, LoggerTypes> entry : classLoaderLoggerMap.entrySet()) {
ClassLoader classLoader = entry.getKey();
LoggerTypes loggerTypes = entry.getValue();
if (loggerTypes.contains(LoggerType.LOG4J)) {
Map<String, Map<String, Object>> loggerInfoMap = loggerInfo(classLoader, Log4jHelper.class);
process.appendResult(new LoggerModel(loggerInfoMap));
}
if (loggerTypes.contains(LoggerType.LOGBACK)) {
Map<String, Map<String, Object>> loggerInfoMap = loggerInfo(classLoader, LogbackHelper.class);
process.appendResult(new LoggerModel(loggerInfoMap));
}
if (loggerTypes.contains(LoggerType.LOG4J2)) {
Map<String, Map<String, Object>> loggerInfoMap = loggerInfo(classLoader, Log4j2Helper.class);
process.appendResult(new LoggerModel(loggerInfoMap));
}
}
process.end();
}
private LoggerTypes findLoggerTypes(Instrumentation inst, ClassLoader classLoader) {
LoggerTypes loggerTypes = new LoggerTypes();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if(classLoader == clazz.getClassLoader()) {
updateLoggerType(loggerTypes, classLoader, clazz.getName());
}
}
return loggerTypes;
}
private void updateLoggerType(LoggerTypes loggerTypes, ClassLoader classLoader, String className) {
if ("org.apache.log4j.Logger".equals(className)) {
// 判断 org.apache.log4j.AsyncAppender 是否存在，如果存在则是 log4j，不是slf4j-over-log4j
try {
if (classLoader.getResource("org/apache/log4j/AsyncAppender.class") != null) {
loggerTypes.addType(LoggerType.LOG4J);
}
} catch (Throwable e) {
// ignore
}
} else if ("ch.qos.logback.classic.Logger".equals(className)) {
try {
if (classLoader.getResource("ch/qos/logback/core/Appender.class") != null) {
loggerTypes.addType(LoggerType.LOGBACK);
}
} catch (Throwable e) {
// ignore
}
} else if ("org.apache.logging.log4j.Logger".equals(className)) {
try {
if (classLoader.getResource("org/apache/logging/log4j/core/LoggerContext.class") != null) {
loggerTypes.addType(LoggerType.LOG4J2);
}
} catch (Throwable e) {
// ignore
}
}
}
private static Class<?> helperClassNameWithClassLoader(ClassLoader classLoader, Class<?> helperClass) {
String classLoaderHash = ClassLoaderUtils.classLoaderHash(classLoader);
String className = helperClass.getName();
// if want to debug, change to return className
String helperClassName = className + arthasClassLoaderHash + classLoaderHash;
try {
return classLoader.loadClass(helperClassName);
} catch (ClassNotFoundException e) {
try {
byte[] helperClassBytes = AsmRenameUtil.renameClass(classToBytesMap.get(helperClass),
helperClass.getName(), helperClassName);
return ReflectUtils.defineClass(helperClassName, helperClassBytes, classLoader);
} catch (Throwable e1) {
logger.error("arthas loggger command try to define helper class error: " + helperClassName,
e1);
}
}
return null;
}
@SuppressWarnings("unchecked")
private Map<String, Map<String, Object>> loggerInfo(ClassLoader classLoader, Class<?> helperClass) {
Map<String, Map<String, Object>> loggers = Collections.emptyMap();
try {
Class<?> clazz = helperClassNameWithClassLoader(classLoader, helperClass);
Method getLoggersMethod = clazz.getMethod("getLoggers", new Class<?>[]{String.class, boolean.class});
loggers = (Map<String, Map<String, Object>>) getLoggersMethod.invoke(null,
new Object[]{name, includeNoAppender});
} catch (Throwable e) {
// ignore
}
//expose attributes to json: classloader, classloaderHash
for (Map<String, Object> loggerInfo : loggers.values()) {
Class clazz = (Class) loggerInfo.get(LoggerHelper.clazz);
loggerInfo.put(LoggerHelper.classLoader, getClassLoaderName(clazz.getClassLoader()));
loggerInfo.put(LoggerHelper.classLoaderHash, StringUtils.classLoaderHash(clazz));
List<Map<String, Object>> appenders = (List<Map<String, Object>>) loggerInfo.get(LoggerHelper.appenders);
for (Map<String, Object> appenderInfo : appenders) {
Class appenderClass = (Class) appenderInfo.get(LoggerHelper.clazz);
if (appenderClass != null) {
appenderInfo.put(LoggerHelper.classLoader, getClassLoaderName(appenderClass.getClassLoader()));
appenderInfo.put(LoggerHelper.classLoaderHash, StringUtils.classLoaderHash(appenderClass));
}
}
}
return loggers;
}
private String getClassLoaderName(ClassLoader classLoader) {
return classLoader == null ? null : classLoader.toString();
}
private Boolean updateLevel(Instrumentation inst, ClassLoader classLoader, Class<?> helperClass) throws Exception {
Class<?> clazz = helperClassNameWithClassLoader(classLoader, helperClass);
Method updateLevelMethod = clazz.getMethod("updateLevel", new Class<?>[]{String.class, String.class});
return (Boolean) updateLevelMethod.invoke(null, new Object[]{this.name, this.level});
}
static enum LoggerType {
LOG4J, LOGBACK, LOG4J2
}
static class LoggerTypes {
Set<LoggerType> types = new HashSet<LoggerType>();
public Collection<LoggerType> types() {
return types;
}
public void addType(LoggerType type) {
types.add(type);
}
public boolean contains(LoggerType type) {
return types.contains(type);
}
}
private static byte[] loadClassBytes(Class<?> clazz) {
try {
InputStream stream = LoggerCommand.class.getClassLoader()
.getResourceAsStream(clazz.getName().replace('.', '/') + ".class");
return IOUtils.getBytes(stream);
} catch (IOException e) {
// ignore
return null;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/Log4jHelper.java | core/src/main/java/com/taobao/arthas/core/command/logger/Log4jHelper.java | package com.taobao.arthas.core.command.logger;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Appender;
import org.apache.log4j.AsyncAppender;
import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
/**
*
* @author hengyunabc 2019-09-06
*
*/
public class Log4jHelper {
private static boolean Log4j = false;
static {
try {
Class<?> loggerClass = Log4jHelper.class.getClassLoader().loadClass("org.apache.log4j.Logger");
// 这里可能会加载到其它上游ClassLoader的log4j，因此需要判断是否当前classloader
if (loggerClass.getClassLoader().equals(Log4jHelper.class.getClassLoader())) {
Log4j = true;
}
} catch (Throwable t) {
}
}
public static Boolean updateLevel(String name, String level) {
if (Log4j) {
Level l = Level.toLevel(level, Level.ERROR);
Logger logger = LogManager.getLoggerRepository().exists(name);
if (logger != null) {
logger.setLevel(l);
return true;
} else {
Logger root = LogManager.getLoggerRepository().getRootLogger();
if (root.getName().equals(name)) {
root.setLevel(l);
return true;
}
}
return false;
}
return null;
}
public static Map<String, Map<String, Object>> getLoggers(String name, boolean includeNoAppender) {
Map<String, Map<String, Object>> loggerInfoMap = new HashMap<String, Map<String, Object>>();
if (!Log4j) {
return loggerInfoMap;
}
if (name != null && !name.trim().isEmpty()) {
Logger logger = LogManager.getLoggerRepository().exists(name);
if (logger != null) {
loggerInfoMap.put(name, doGetLoggerInfo(logger));
}
} else {
// 获取所有logger时，如果没有appender则忽略
@SuppressWarnings("unchecked")
Enumeration<Logger> loggers = LogManager.getLoggerRepository().getCurrentLoggers();
if (loggers != null) {
while (loggers.hasMoreElements()) {
Logger logger = loggers.nextElement();
Map<String, Object> info = doGetLoggerInfo(logger);
if (!includeNoAppender) {
List<?> appenders = (List<?>) info.get(LoggerHelper.appenders);
if (appenders != null && !appenders.isEmpty()) {
loggerInfoMap.put(logger.getName(), info);
}
} else {
loggerInfoMap.put(logger.getName(), info);
}
}
}
Logger root = LogManager.getLoggerRepository().getRootLogger();
if (root != null) {
Map<String, Object> info = doGetLoggerInfo(root);
if (!includeNoAppender) {
List<?> appenders = (List<?>) info.get(LoggerHelper.appenders);
if (appenders != null && !appenders.isEmpty()) {
loggerInfoMap.put(root.getName(), info);
}
} else {
loggerInfoMap.put(root.getName(), info);
}
}
}
return loggerInfoMap;
}
private static Map<String, Object> doGetLoggerInfo(Logger logger) {
Map<String, Object> info = new HashMap<String, Object>();
info.put(LoggerHelper.name, logger.getName());
info.put(LoggerHelper.clazz, logger.getClass());
CodeSource codeSource = logger.getClass().getProtectionDomain().getCodeSource();
if (codeSource != null) {
info.put(LoggerHelper.codeSource, codeSource.getLocation());
}
info.put(LoggerHelper.additivity, logger.getAdditivity());
Level level = logger.getLevel(), effectiveLevel = logger.getEffectiveLevel();
if (level != null) {
info.put(LoggerHelper.level, level.toString());
}
if (effectiveLevel != null) {
info.put(LoggerHelper.effectiveLevel, effectiveLevel.toString());
}
@SuppressWarnings("unchecked")
List<Map<String, Object>> result = doGetLoggerAppenders(logger.getAllAppenders());
info.put(LoggerHelper.appenders, result);
return info;
}
private static List<Map<String, Object>> doGetLoggerAppenders(Enumeration<Appender> appenders) {
List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
if (appenders == null) {
return result;
}
while (appenders.hasMoreElements()) {
Map<String, Object> info = new HashMap<String, Object>();
Appender appender = appenders.nextElement();
info.put(LoggerHelper.name, appender.getName());
info.put(LoggerHelper.clazz, appender.getClass());
result.add(info);
if (appender instanceof FileAppender) {
info.put(LoggerHelper.file, ((FileAppender) appender).getFile());
} else if (appender instanceof ConsoleAppender) {
info.put(LoggerHelper.target, ((ConsoleAppender) appender).getTarget());
} else if (appender instanceof AsyncAppender) {
@SuppressWarnings("unchecked")
Enumeration<Appender> appendersOfAsync = ((AsyncAppender) appender).getAllAppenders();
if (appendersOfAsync != null) {
List<Map<String, Object>> asyncs = doGetLoggerAppenders(appendersOfAsync);
// 标明异步appender
List<String> appenderRef = new ArrayList<String>();
for (Map<String, Object> a : asyncs) {
appenderRef.add((String) a.get(LoggerHelper.name));
result.add(a);
}
info.put(LoggerHelper.blocking, ((AsyncAppender) appender).getBlocking());
info.put(LoggerHelper.appenderRef, appenderRef);
}
}
}
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/AsmRenameUtil.java | core/src/main/java/com/taobao/arthas/core/command/logger/AsmRenameUtil.java | package com.taobao.arthas.core.command.logger;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.alibaba.deps.org.objectweb.asm.ClassVisitor;
import com.alibaba.deps.org.objectweb.asm.ClassWriter;
import com.alibaba.deps.org.objectweb.asm.commons.ClassRemapper;
import com.alibaba.deps.org.objectweb.asm.commons.SimpleRemapper;
/**
*
* @author hengyunabc 2019-09-23
*
*/
public class AsmRenameUtil {
public static byte[] renameClass(byte[] bytes, final String oldName, final String newName) {
ClassReader reader = new ClassReader(bytes);
ClassWriter writer = new ClassWriter(reader, 0);
final String internalOldName = oldName.replace('.', '/');
final String internalNewName = newName.replace('.', '/');
// ClassVisitor visitor = new ClassRemapper(writer, new Remapper() {
//
// @Override
// public String mapType(String internalName) {
// if (internalName.equals(internalOldName)) {
// return internalNewName;
// } else {
// return super.mapType(internalName);
// }
// }
//
// });
ClassVisitor visitor = new ClassRemapper(writer, new SimpleRemapper(internalOldName, internalNewName));
reader.accept(visitor, 0);
return writer.toByteArray();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/LoggerHelper.java | core/src/main/java/com/taobao/arthas/core/command/logger/LoggerHelper.java | package com.taobao.arthas.core.command.logger;
/**
*
* @author hengyunabc 2019-09-06
*
*/
public interface LoggerHelper {
public static final String clazz = "class";
public static final String classLoader = "classLoader";
public static final String classLoaderHash = "classLoaderHash";
public static final String codeSource = "codeSource";
// logger info
public static final String level = "level";
public static final String effectiveLevel = "effectiveLevel";
// log4j2 only
public static final String config = "config";
// type boolean
public static final String additivity = "additivity";
public static final String appenders = "appenders";
// appender info
public static final String name = "name";
public static final String file = "file";
public static final String blocking = "blocking";
// type List<String>
public static final String appenderRef = "appenderRef";
public static final String target = "target";
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/logger/LogbackHelper.java | core/src/main/java/com/taobao/arthas/core/command/logger/LogbackHelper.java | package com.taobao.arthas.core.command.logger;
import java.lang.reflect.Field;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.ILoggerFactory;
import ch.qos.logback.classic.AsyncAppender;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.Appender;
import ch.qos.logback.core.ConsoleAppender;
import ch.qos.logback.core.FileAppender;
import ch.qos.logback.core.pattern.PatternLayoutBase;
/**
*
* @author hengyunabc 2019-09-06
*
*/
public class LogbackHelper {
private static boolean Logback = false;
private static Field headField, lengthOptionField;
private static ILoggerFactory loggerFactoryInstance;
static {
try {
Class<?> loggerClass = LogbackHelper.class.getClassLoader().loadClass("ch.qos.logback.classic.Logger");
// 这里可能会加载到应用中依赖的logback，因此需要判断classloader
if (loggerClass.getClassLoader().equals(LogbackHelper.class.getClassLoader())) {
ILoggerFactory loggerFactory = org.slf4j.LoggerFactory.getILoggerFactory();
if (loggerFactory instanceof LoggerContext) {
loggerFactoryInstance = loggerFactory;
headField = PatternLayoutBase.class.getDeclaredField("head");
headField.setAccessible(true);
lengthOptionField = ThrowableProxyConverter.class.getDeclaredField("lengthOption");
lengthOptionField.setAccessible(true);
Logback = true;
}
}
} catch (Throwable t) {
// ignore
}
}
public static Boolean updateLevel(String name, String level) {
if (Logback) {
try {
Level l = Level.toLevel(level, Level.ERROR);
LoggerContext loggerContext = (LoggerContext) loggerFactoryInstance;
Logger logger = loggerContext.exists(name);
if (logger != null) {
logger.setLevel(l);
return true;
}
} catch (Throwable t) {
// ignore
}
return false;
}
return null;
}
public static Map<String, Map<String, Object>> getLoggers(String name, boolean includeNoAppender) {
Map<String, Map<String, Object>> loggerInfoMap = new LinkedHashMap<String, Map<String, Object>>();
if (Logback) {
LoggerContext loggerContext = (LoggerContext) loggerFactoryInstance;
if (name != null && !name.trim().isEmpty()) {
Logger logger = loggerContext.exists(name);
if (logger != null) {
loggerInfoMap.put(name, doGetLoggerInfo(logger));
}
} else {
// 获取所有logger时，如果没有appender则忽略
List<Logger> loggers = loggerContext.getLoggerList();
for (Logger logger : loggers) {
Map<String, Object> info = doGetLoggerInfo(logger);
if (!includeNoAppender) {
List<?> appenders = (List<?>) info.get(LoggerHelper.appenders);
if (appenders != null && !appenders.isEmpty()) {
loggerInfoMap.put(logger.getName(), info);
}
} else {
loggerInfoMap.put(logger.getName(), info);
}
}
}
}
return loggerInfoMap;
}
private static Map<String, Object> doGetLoggerInfo(Logger logger) {
Map<String, Object> info = new LinkedHashMap<String, Object>();
info.put(LoggerHelper.name, logger.getName());
info.put(LoggerHelper.clazz, logger.getClass());
CodeSource codeSource = logger.getClass().getProtectionDomain().getCodeSource();
if (codeSource != null) {
info.put(LoggerHelper.codeSource, codeSource.getLocation());
}
info.put(LoggerHelper.additivity, logger.isAdditive());
Level level = logger.getLevel(), effectiveLevel = logger.getEffectiveLevel();
if (level != null) {
info.put(LoggerHelper.level, level.toString());
}
if (effectiveLevel != null) {
info.put(LoggerHelper.effectiveLevel, effectiveLevel.toString());
}
List<Map<String, Object>> result = doGetLoggerAppenders(logger.iteratorForAppenders());
info.put(LoggerHelper.appenders, result);
return info;
}
@SuppressWarnings("rawtypes")
private static List<Map<String, Object>> doGetLoggerAppenders(Iterator<Appender<ILoggingEvent>> appenders) {
List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
while (appenders.hasNext()) {
Map<String, Object> info = new LinkedHashMap<String, Object>();
Appender<ILoggingEvent> appender = appenders.next();
info.put(LoggerHelper.name, appender.getName());
info.put(LoggerHelper.clazz, appender.getClass());
if (appender instanceof FileAppender) {
info.put(LoggerHelper.file, ((FileAppender) appender).getFile());
} else if (appender instanceof AsyncAppender) {
AsyncAppender aa = (AsyncAppender) appender;
Iterator<Appender<ILoggingEvent>> iter = aa.iteratorForAppenders();
List<Map<String, Object>> asyncs = doGetLoggerAppenders(iter);
// 异步appender所 ref的 appender，参考： https://logback.qos.ch/manual/appenders.html
List<String> appenderRef = new ArrayList<String>();
for (Map<String, Object> a : asyncs) {
appenderRef.add((String) a.get(LoggerHelper.name));
result.add(a);
}
info.put(LoggerHelper.appenderRef, appenderRef);
info.put(LoggerHelper.blocking, !aa.isNeverBlock());
} else if (appender instanceof ConsoleAppender) {
info.put(LoggerHelper.target, ((ConsoleAppender) appender).getTarget());
}
result.add(info);
}
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/DashboardCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/DashboardCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.atomic.AtomicLong;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.DashboardModel;
import com.taobao.arthas.core.command.model.GcInfoVO;
import com.taobao.arthas.core.command.model.RuntimeInfoVO;
import com.taobao.arthas.core.command.model.ThreadVO;
import com.taobao.arthas.core.command.model.TomcatInfoVO;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.shell.QExitHandler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.util.NetUtils;
import com.taobao.arthas.core.util.NetUtils.Response;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.ThreadUtil;
import com.taobao.arthas.core.util.metrics.SumRateCounter;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* @author hengyunabc 2015年11月19日 上午11:57:21
*/
@Name("dashboard")
@Summary("Overview of target jvm's thread, memory, gc, vm, tomcat info.")
@Description(Constants.EXAMPLE +
" dashboard\n" +
" dashboard -n 10\n" +
" dashboard -i 2000\n" +
Constants.WIKI + Constants.WIKI_HOME + "dashboard")
public class DashboardCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(DashboardCommand.class);
private SumRateCounter tomcatRequestCounter = new SumRateCounter();
private SumRateCounter tomcatErrorCounter = new SumRateCounter();
private SumRateCounter tomcatReceivedBytesCounter = new SumRateCounter();
private SumRateCounter tomcatSentBytesCounter = new SumRateCounter();
private int numOfExecutions = Integer.MAX_VALUE;
private long interval = 5000;
private final AtomicLong count = new AtomicLong(0);
private volatile Timer timer;
@Option(shortName = "n", longName = "number-of-execution")
@Description("The number of times this command will be executed.")
public void setNumOfExecutions(int numOfExecutions) {
this.numOfExecutions = numOfExecutions;
}
@Option(shortName = "i", longName = "interval")
@Description("The interval (in ms) between two executions, default is 5000 ms.")
public void setInterval(long interval) {
this.interval = interval;
}
@Override
public void process(final CommandProcess process) {
Session session = process.session();
timer = new Timer("Timer-for-arthas-dashboard-" + session.getSessionId(), true);
// ctrl-C support
process.interruptHandler(new DashboardInterruptHandler(process, timer));
/*
* 通过handle回调，在suspend和end时停止timer，resume时重启timer
*/
Handler<Void> stopHandler = new Handler<Void>() {
@Override
public void handle(Void event) {
stop();
}
};
Handler<Void> restartHandler = new Handler<Void>() {
@Override
public void handle(Void event) {
restart(process);
}
};
process.suspendHandler(stopHandler);
process.resumeHandler(restartHandler);
process.endHandler(stopHandler);
// q exit support
process.stdinHandler(new QExitHandler(process));
// start the timer
timer.scheduleAtFixedRate(new DashboardTimerTask(process), 0, getInterval());
}
public synchronized void stop() {
if (timer != null) {
timer.cancel();
timer.purge();
timer = null;
}
}
public synchronized void restart(CommandProcess process) {
if (timer == null) {
Session session = process.session();
timer = new Timer("Timer-for-arthas-dashboard-" + session.getSessionId(), true);
timer.scheduleAtFixedRate(new DashboardTimerTask(process), 0, getInterval());
}
}
public int getNumOfExecutions() {
return numOfExecutions;
}
public long getInterval() {
return interval;
}
private static void addRuntimeInfo(DashboardModel dashboardModel) {
RuntimeInfoVO runtimeInfo = new RuntimeInfoVO();
runtimeInfo.setOsName(System.getProperty("os.name"));
runtimeInfo.setOsVersion(System.getProperty("os.version"));
runtimeInfo.setJavaVersion(System.getProperty("java.version"));
runtimeInfo.setJavaHome(System.getProperty("java.home"));
runtimeInfo.setSystemLoadAverage(ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage());
runtimeInfo.setProcessors(Runtime.getRuntime().availableProcessors());
runtimeInfo.setUptime(ManagementFactory.getRuntimeMXBean().getUptime() / 1000);
runtimeInfo.setTimestamp(System.currentTimeMillis());
dashboardModel.setRuntimeInfo(runtimeInfo);
}
private static void addGcInfo(DashboardModel dashboardModel) {
List<GcInfoVO> gcInfos = new ArrayList<GcInfoVO>();
dashboardModel.setGcInfos(gcInfos);
List<GarbageCollectorMXBean> garbageCollectorMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean gcMXBean : garbageCollectorMxBeans) {
String name = gcMXBean.getName();
gcInfos.add(new GcInfoVO(StringUtils.beautifyName(name), gcMXBean.getCollectionCount(), gcMXBean.getCollectionTime()));
}
}
private void addTomcatInfo(DashboardModel dashboardModel) {
// 如果请求tomcat信息失败，则不显示tomcat信息
if (!NetUtils.request("http://localhost:8006").isSuccess()) {
return;
}
TomcatInfoVO tomcatInfoVO = new TomcatInfoVO();
dashboardModel.setTomcatInfo(tomcatInfoVO);
String threadPoolPath = "http://localhost:8006/connector/threadpool";
String connectorStatPath = "http://localhost:8006/connector/stats";
Response connectorStatResponse = NetUtils.request(connectorStatPath);
if (connectorStatResponse.isSuccess()) {
List<TomcatInfoVO.ConnectorStats> connectorStats = new ArrayList<TomcatInfoVO.ConnectorStats>();
List<JSONObject> tomcatConnectorStats = JSON.parseArray(connectorStatResponse.getContent(), JSONObject.class);
for (JSONObject stat : tomcatConnectorStats) {
String connectorName = stat.getString("name").replace("\"", "");
long bytesReceived = stat.getLongValue("bytesReceived");
long bytesSent = stat.getLongValue("bytesSent");
long processingTime = stat.getLongValue("processingTime");
long requestCount = stat.getLongValue("requestCount");
long errorCount = stat.getLongValue("errorCount");
tomcatRequestCounter.update(requestCount);
tomcatErrorCounter.update(errorCount);
tomcatReceivedBytesCounter.update(bytesReceived);
tomcatSentBytesCounter.update(bytesSent);
double qps = tomcatRequestCounter.rate();
double rt = processingTime / (double) requestCount;
double errorRate = tomcatErrorCounter.rate();
long receivedBytesRate = Double.valueOf(tomcatReceivedBytesCounter.rate()).longValue();
long sentBytesRate = Double.valueOf(tomcatSentBytesCounter.rate()).longValue();
TomcatInfoVO.ConnectorStats connectorStat = new TomcatInfoVO.ConnectorStats();
connectorStat.setName(connectorName);
connectorStat.setQps(qps);
connectorStat.setRt(rt);
connectorStat.setError(errorRate);
connectorStat.setReceived(receivedBytesRate);
connectorStat.setSent(sentBytesRate);
connectorStats.add(connectorStat);
}
tomcatInfoVO.setConnectorStats(connectorStats);
}
Response threadPoolResponse = NetUtils.request(threadPoolPath);
if (threadPoolResponse.isSuccess()) {
List<TomcatInfoVO.ThreadPool> threadPools = new ArrayList<TomcatInfoVO.ThreadPool>();
List<JSONObject> threadPoolInfos = JSON.parseArray(threadPoolResponse.getContent(), JSONObject.class);
for (JSONObject info : threadPoolInfos) {
String name = info.getString("name").replace("\"", "");
long busy = info.getLongValue("threadBusy");
long total = info.getLongValue("threadCount");
threadPools.add(new TomcatInfoVO.ThreadPool(name, busy, total));
}
tomcatInfoVO.setThreadPools(threadPools);
}
}
private class DashboardTimerTask extends TimerTask {
private CommandProcess process;
private ThreadSampler threadSampler;
public DashboardTimerTask(CommandProcess process) {
this.process = process;
this.threadSampler = new ThreadSampler();
}
@Override
public void run() {
try {
if (count.get() >= getNumOfExecutions()) {
// stop the timer
timer.cancel();
timer.purge();
process.end(0, "Process ends after " + getNumOfExecutions() + " time(s).");
return;
}
DashboardModel dashboardModel = new DashboardModel();
//thread sample
List<ThreadVO> threads = ThreadUtil.getThreads();
dashboardModel.setThreads(threadSampler.sample(threads));
//memory
dashboardModel.setMemoryInfo(MemoryCommand.memoryInfo());
//gc
addGcInfo(dashboardModel);
//runtime
addRuntimeInfo(dashboardModel);
//tomcat
try {
addTomcatInfo(dashboardModel);
} catch (Throwable e) {
logger.error("try to read tomcat info error", e);
}
process.appendResult(dashboardModel);
count.getAndIncrement();
process.times().incrementAndGet();
} catch (Throwable e) {
String msg = "process dashboard failed: " + e.getMessage();
logger.error(msg, e);
process.end(-1, msg);
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/VmToolCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/VmToolCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.instrument.Instrumentation;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.IOUtils;
import com.taobao.arthas.common.VmToolUtils;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.express.Express;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.command.model.ClassLoaderVO;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.command.model.VmToolModel;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.cli.OptionCompleteHandler;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.ClassLoaderUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import arthas.VmTool;
/**
*
* @author hengyunabc 2021-04-27
* @author ZhangZiCheng 2021-04-29
*
*/
//@formatter:off
@Name("vmtool")
@Summary("jvm tool")
@Description(Constants.EXAMPLE
+ " vmtool --action getInstances --className demo.MathGame\n"
+ " vmtool --action getInstances --className demo.MathGame --express 'instances.length'\n"
+ " vmtool --action getInstances --className demo.MathGame --express 'instances[0]'\n"
+ " vmtool --action getInstances --className demo.MathGame -x 2\n"
+ " vmtool --action getInstances --className java.lang.String --limit 10\n"
+ " vmtool --action getInstances --classLoaderClass org.springframework.boot.loader.LaunchedURLClassLoader --className org.springframework.context.ApplicationContext\n"
+ " vmtool --action forceGc\n"
+ " vmtool --action heapAnalyze --classNum 20 --objectNum 20\n"
+ " vmtool --action referenceAnalyze --className java.lang.String --objectNum 20 --backtraceNum 2\n"
+ " vmtool --action interruptThread -t 1\n"
+ " vmtool --action mallocTrim\n"
+ " vmtool --action mallocStats\n"
+ Constants.WIKI + Constants.WIKI_HOME + "vmtool")
//@formatter:on
public class VmToolCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(VmToolCommand.class);
private VmToolAction action;
private String className;
private String express;
private int threadId;
private String hashCode = null;
private String classLoaderClass;
/**
* default value 1
*/
private int expand;
/**
* default value 10
*/
private int limit;
/**
* default value 20
*/
private int classNum = 20;
/**
* default value 20
*/
private int objectNum = 20;
/**
* default value 2
*/
private int backtraceNum = 2;
private String libPath;
private static String defaultLibPath;
private static VmTool vmTool = null;
static {
String libName = VmToolUtils.detectLibName();
if (libName != null) {
CodeSource codeSource = VmToolCommand.class.getProtectionDomain().getCodeSource();
if (codeSource != null) {
try {
File bootJarPath = new File(codeSource.getLocation().toURI().getSchemeSpecificPart());
File soFile = new File(bootJarPath.getParentFile(), "lib" + File.separator + libName);
if (soFile.exists()) {
defaultLibPath = soFile.getAbsolutePath();
}
} catch (Throwable e) {
logger.error("can not find VmTool so", e);
}
}
}
}
@Option(shortName = "a", longName = "action", required = true)
@Description("Action to execute")
public void setAction(VmToolAction action) {
this.action = action;
}
@Option(longName = "className")
@Description("The class name")
public void setClassName(String className) {
this.className = className;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (1 by default)")
@DefaultValue("1")
public void setExpand(int expand) {
this.expand = expand;
}
@Option(shortName = "c", longName = "classloader")
@Description("The hash code of the special class's classLoader")
public void setHashCode(String hashCode) {
this.hashCode = hashCode;
}
@Option(longName = "classLoaderClass")
@Description("The class name of the special class's classLoader.")
public void setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
}
@Option(shortName = "l", longName = "limit")
@Description("Set the limit value of the getInstances action, default value is 10, set to -1 is unlimited")
@DefaultValue("10")
public void setLimit(int limit) {
this.limit = limit;
}
@Option(longName = "classNum", required = false)
@Description("The number of classes to be shown.")
public void setClassNum(int classNum) {
this.classNum = classNum;
}
@Option(longName = "objectNum", required = false)
@Description("The number of objects to be shown.")
public void setObjectNum(int objectNum) {
this.objectNum = objectNum;
}
@Option(longName = "backtraceNum", required = false)
@Description("The steps of backtrace by reference.")
public void setBacktraceNum(int backtraceNum) {
this.backtraceNum = backtraceNum;
}
@Option(longName = "libPath")
@Description("The specify lib path.")
public void setLibPath(String path) {
libPath = path;
}
@Option(longName = "express", required = false)
@Description("The ognl expression, default value is `instances`.")
public void setExpress(String express) {
this.express = express;
}
@Option(shortName = "t", longName = "threadId", required = false)
@Description("The id of the thread to be interrupted")
public void setThreadId(int threadId) {
this.threadId = threadId;
}
public enum VmToolAction {
getInstances, forceGc, heapAnalyze, referenceAnalyze, interruptThread, mallocTrim, mallocStats
}
@Override
public void process(final CommandProcess process) {
try {
Instrumentation inst = process.session().getInstrumentation();
if (VmToolAction.getInstances.equals(action) || VmToolAction.referenceAnalyze.equals(action)) {
if (className == null) {
process.end(-1, "The className option cannot be empty!");
return;
}
ClassLoader classLoader = null;
if (hashCode != null) {
classLoader = ClassLoaderUtils.getClassLoader(inst, hashCode);
if (classLoader == null) {
process.end(-1, "Can not find classloader with hashCode: " + hashCode + ".");
return;
}
}else if ( classLoaderClass != null) {
List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst,
classLoaderClass);
if (matchedClassLoaders.size() == 1) {
classLoader = matchedClassLoaders.get(0);
hashCode = Integer.toHexString(matchedClassLoaders.get(0).hashCode());
} else if (matchedClassLoaders.size() > 1) {
Collection<ClassLoaderVO> classLoaderVOList = ClassUtils
.createClassLoaderVOList(matchedClassLoaders);
VmToolModel vmToolModel = new VmToolModel().setClassLoaderClass(classLoaderClass)
.setMatchedClassLoaders(classLoaderVOList);
process.appendResult(vmToolModel);
process.end(-1,
"Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
return;
} else {
process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
return;
}
}else {
classLoader = ClassLoader.getSystemClassLoader();
}
List<Class<?>> matchedClasses = new ArrayList<Class<?>>(
SearchUtils.searchClassOnly(inst, className, false, hashCode));
int matchedClassSize = matchedClasses.size();
if (matchedClassSize == 0) {
process.end(-1, "Can not find class by class name: " + className + ".");
return;
} else if (matchedClassSize > 1) {
process.end(-1, "Found more than one class: " + matchedClasses + ", please specify classloader with '-c <classloader hash>'");
return;
} else {
if (VmToolAction.getInstances.equals(action)) {
Object[] instances = vmToolInstance().getInstances(matchedClasses.get(0), limit);
Object value = instances;
if (express != null) {
Express unpooledExpress = ExpressFactory.unpooledExpress(classLoader);
try {
value = unpooledExpress.bind(new InstancesWrapper(instances)).get(express);
} catch (ExpressException e) {
logger.warn("ognl: failed execute express: " + express, e);
process.end(-1, "Failed to execute ognl, exception message: " + e.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details. ");
}
}
VmToolModel vmToolModel = new VmToolModel().setValue(new ObjectVO(value, expand));
process.appendResult(vmToolModel);
process.end();
} else {
String result = vmToolInstance().referenceAnalyze(matchedClasses.get(0), objectNum, backtraceNum);
process.write(result);
process.end();
}
}
} else if (VmToolAction.forceGc.equals(action)) {
vmToolInstance().forceGc();
process.write("\n");
process.end();
return;
} else if (VmToolAction.heapAnalyze.equals(action)) {
String result = vmToolInstance().heapAnalyze(classNum, objectNum);
process.write(result);
process.end();
return;
} else if (VmToolAction.interruptThread.equals(action)) {
vmToolInstance().interruptSpecialThread(threadId);
process.write("\n");
process.end();
return;
} else if (VmToolAction.mallocTrim.equals(action)) {
int result = vmToolInstance().mallocTrim();
process.write("\n");
process.end(result == 1 ? 0 : -1, "mallocTrim result: " +
(result == 1 ? "true" : (result == 0 ? "false" : "not supported")));
return;
} else if (VmToolAction.mallocStats.equals(action)) {
boolean result = vmToolInstance().mallocStats();
process.write("\n");
process.end(result ? 0 : -1, "mallocStats result: " +
(result ? "true" : "not supported"));
return;
}
process.end();
} catch (Throwable e) {
logger.error("vmtool error", e);
process.end(1, "vmtool error: " + e.getMessage());
}
}
static class InstancesWrapper {
Object instances;
public InstancesWrapper(Object instances) {
this.instances = instances;
}
public Object getInstances() {
return instances;
}
public void setInstances(Object instances) {
this.instances = instances;
}
}
private VmTool vmToolInstance() {
if (vmTool != null) {
return vmTool;
} else {
if (libPath == null) {
libPath = defaultLibPath;
}
// 尝试把lib文件复制到临时文件里，避免多次attach时出现 Native Library already loaded in another classloader
FileOutputStream tmpLibOutputStream = null;
FileInputStream libInputStream = null;
try {
File tmpLibFile = File.createTempFile(VmTool.JNI_LIBRARY_NAME, null);
tmpLibOutputStream = new FileOutputStream(tmpLibFile);
libInputStream = new FileInputStream(libPath);
IOUtils.copy(libInputStream, tmpLibOutputStream);
libPath = tmpLibFile.getAbsolutePath();
logger.debug("copy {} to {}", libPath, tmpLibFile);
} catch (Throwable e) {
logger.error("try to copy lib error! libPath: {}", libPath, e);
} finally {
IOUtils.close(libInputStream);
IOUtils.close(tmpLibOutputStream);
}
vmTool = VmTool.getInstance(libPath);
}
return vmTool;
}
private Set<String> actions() {
Set<String> values = new HashSet<String>();
for (VmToolAction action : VmToolAction.values()) {
values.add(action.toString());
}
return values;
}
@Override
public void complete(Completion completion) {
List<OptionCompleteHandler> handlers = new ArrayList<OptionCompleteHandler>();
handlers.add(new OptionCompleteHandler() {
@Override
public boolean matchName(String token) {
return "-a".equals(token) || "--action".equals(token);
}
@Override
public boolean complete(Completion completion) {
return CompletionUtils.complete(completion, actions());
}
});
handlers.add(new OptionCompleteHandler() {
@Override
public boolean matchName(String token) {
return "--className".equals(token);
}
@Override
public boolean complete(Completion completion) {
return CompletionUtils.completeClassName(completion);
}
});
if (CompletionUtils.completeOptions(completion, handlers)) {
return;
}
super.complete(completion);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/HeapDumpCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/HeapDumpCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.sun.management.HotSpotDiagnosticMXBean;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.HeapDumpModel;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* HeapDump command
*
* @author hengyunabc 2019-09-02
*
*/
@Name("heapdump")
@Summary("Heap dump")
@Description("\nExamples:\n" + " heapdump\n" + " heapdump --live\n" + " heapdump --live /tmp/dump.hprof\n"
+ Constants.WIKI + Constants.WIKI_HOME + "heapdump")
public class HeapDumpCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(HeapDumpCommand.class);
private String file;
private boolean live;
@Argument(argName = "file", index = 0, required = false)
@Description("Output file")
public void setFile(String file) {
this.file = file;
}
@Option(shortName = "l", longName = "live", flag = true)
@Description("Dump only live objects; if not specified, all objects in the heap are dumped.")
public void setLive(boolean live) {
this.live = live;
}
@Override
public void process(CommandProcess process) {
try {
String dumpFile = file;
if (dumpFile == null || dumpFile.isEmpty()) {
String date = new SimpleDateFormat("yyyy-MM-dd-HH-mm").format(new Date());
File file = File.createTempFile("heapdump" + date + (live ? "-live" : ""), ".hprof");
dumpFile = file.getAbsolutePath();
file.delete();
}
process.appendResult(new MessageModel("Dumping heap to " + dumpFile + " ..."));
run(process, dumpFile, live);
process.appendResult(new MessageModel("Heap dump file created"));
process.appendResult(new HeapDumpModel(dumpFile, live));
process.end();
} catch (Throwable t) {
String errorMsg = "heap dump error: " + t.getMessage();
logger.error(errorMsg, t);
process.end(-1, errorMsg);
}
}
private static void run(CommandProcess process, String file, boolean live) throws IOException {
HotSpotDiagnosticMXBean hotSpotDiagnosticMXBean = ManagementFactory
.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
hotSpotDiagnosticMXBean.dumpHeap(file, live);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.command.model.*;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.command.CommandInterruptHandler;
import com.taobao.arthas.core.shell.handlers.shell.QExitHandler;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.RowAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.middleware.cli.annotations.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static java.lang.Integer.toHexString;
import static java.lang.String.format;
/**
* 时光隧道命令<br/>
* 参数w/d依赖于参数i所传递的记录编号<br/>
*
* @author vlinux on 14/11/15.
*/
@Name("tt")
@Summary("Time Tunnel")
@Description(Constants.EXPRESS_DESCRIPTION + Constants.EXAMPLE +
" tt -t *StringUtils isEmpty\n" +
" tt -t *StringUtils isEmpty params[0].length==1\n" +
" tt -l\n" +
" tt -i 1000\n" +
" tt -i 1000 -w params[0]\n" +
" tt -i 1000 -p \n" +
" tt -i 1000 -p --replay-times 3 --replay-interval 3000\n" +
" tt -s '{params[0] > 1}' -w '{params}' \n" +
" tt --delete-all\n" +
Constants.WIKI + Constants.WIKI_HOME + "tt")
public class TimeTunnelCommand extends EnhancerCommand {
// 时间隧道(时间碎片的集合)
// TODO 并非线程安全？
private static final Map<Integer, TimeFragment> timeFragmentMap = new LinkedHashMap<Integer, TimeFragment>();
// 时间碎片序列生成器
private static final AtomicInteger sequence = new AtomicInteger(1000);
// TimeTunnel the method call
private boolean isTimeTunnel = false;
private String classPattern;
private String methodPattern;
private String conditionExpress;
// list the TimeTunnel
private boolean isList = false;
private boolean isDeleteAll = false;
// index of TimeTunnel
private Integer index;
// expand of TimeTunnel
private Integer expand = 1;
// upper size limit
private Integer sizeLimit = 10 * 1024 * 1024;
// watch the index TimeTunnel
private String watchExpress = com.taobao.arthas.core.util.Constants.EMPTY_STRING;
private String searchExpress = com.taobao.arthas.core.util.Constants.EMPTY_STRING;
// play the index TimeTunnel
private boolean isPlay = false;
// delete the index TimeTunnel
private boolean isDelete = false;
private boolean isRegEx = false;
private int numberOfLimit = 100;
private int replayTimes = 1;
private long replayInterval = 1000L;
private static final Logger logger = LoggerFactory.getLogger(TimeTunnelCommand.class);
@Argument(index = 0, argName = "class-pattern", required = false)
@Description("Path and classname of Pattern Matching")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Argument(index = 1, argName = "method-pattern", required = false)
@Description("Method of Pattern Matching")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(index = 2, argName = "condition-express", required = false)
@Description(Constants.CONDITION_EXPRESS)
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
@Option(shortName = "t", longName = "time-tunnel", flag = true)
@Description("Record the method invocation within time fragments")
public void setTimeTunnel(boolean timeTunnel) {
isTimeTunnel = timeTunnel;
}
@Option(shortName = "l", longName = "list", flag = true)
@Description("List all the time fragments")
public void setList(boolean list) {
isList = list;
}
@Option(longName = "delete-all", flag = true)
@Description("Delete all the time fragments")
public void setDeleteAll(boolean deleteAll) {
isDeleteAll = deleteAll;
}
@Option(shortName = "i", longName = "index")
@Description("Display the detailed information from specified time fragment")
public void setIndex(Integer index) {
this.index = index;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (1 by default)")
public void setExpand(Integer expand) {
this.expand = expand;
}
@Option(shortName = "M", longName = "sizeLimit")
@Description("Upper size limit in bytes for the result (10 * 1024 * 1024 by default)")
public void setSizeLimit(Integer sizeLimit) {
this.sizeLimit = sizeLimit;
}
@Option(shortName = "w", longName = "watch-express")
@Description(value = "watch the time fragment by ognl express.\n" + Constants.EXPRESS_EXAMPLES)
public void setWatchExpress(String watchExpress) {
this.watchExpress = watchExpress;
}
@Option(shortName = "s", longName = "search-express")
@Description("Search-expression, to search the time fragments by ognl express.\n" +
"The structure of 'advice' like conditional expression")
public void setSearchExpress(String searchExpress) {
this.searchExpress = searchExpress;
}
@Option(shortName = "p", longName = "play", flag = true)
@Description("Replay the time fragment specified by index")
public void setPlay(boolean play) {
isPlay = play;
}
@Option(shortName = "d", longName = "delete", flag = true)
@Description("Delete time fragment specified by index")
public void setDelete(boolean delete) {
isDelete = delete;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "n", longName = "limits")
@Description("Threshold of execution times, default value 100")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
@Option(longName = "replay-times")
@Description("execution times when play tt")
public void setReplayTimes(int replayTimes) {
this.replayTimes = replayTimes;
}
@Option(longName = "replay-interval")
@Description("replay interval for play tt with option r greater than 1")
public void setReplayInterval(int replayInterval) {
this.replayInterval = replayInterval;
}
public boolean isRegEx() {
return isRegEx;
}
public String getMethodPattern() {
return methodPattern;
}
public String getClassPattern() {
return classPattern;
}
public String getConditionExpress() {
return conditionExpress;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
public int getReplayTimes() {
return replayTimes;
}
public long getReplayInterval() {
return replayInterval;
}
public Integer getExpand() {
return expand;
}
private boolean hasWatchExpress() {
return !StringUtils.isEmpty(watchExpress);
}
private boolean hasSearchExpress() {
return !StringUtils.isEmpty(searchExpress);
}
/**
* 检查参数是否合法
*/
private void checkArguments() {
// 检查d/p参数是否有i参数配套
if ((isDelete || isPlay) && null == index) {
throw new IllegalArgumentException("Time fragment index is expected, please type -i to specify");
}
// 在t参数下class-pattern,method-pattern
if (isTimeTunnel) {
if (StringUtils.isEmpty(classPattern)) {
throw new IllegalArgumentException("Class-pattern is expected, please type the wildcard expression to match");
}
if (StringUtils.isEmpty(methodPattern)) {
throw new IllegalArgumentException("Method-pattern is expected, please type the wildcard expression to match");
}
}
// 一个参数都没有是不行滴
if (null == index && !isTimeTunnel && !isDeleteAll && StringUtils.isEmpty(watchExpress)
&& !isList && StringUtils.isEmpty(searchExpress)) {
throw new IllegalArgumentException("Argument(s) is/are expected, type 'help tt' to read usage");
}
}
/*
* 记录时间片段
*/
int putTimeTunnel(TimeFragment tt) {
int indexOfSeq = sequence.getAndIncrement();
timeFragmentMap.put(indexOfSeq, tt);
return indexOfSeq;
}
@Override
public void process(final CommandProcess process) {
// 检查参数
checkArguments();
// ctrl-C support
process.interruptHandler(new CommandInterruptHandler(process));
// q exit support
process.stdinHandler(new QExitHandler(process));
if (isTimeTunnel) {
enhance(process);
} else if (isPlay) {
processPlay(process);
} else if (isList) {
processList(process);
} else if (isDeleteAll) {
processDeleteAll(process);
} else if (isDelete) {
processDelete(process);
} else if (hasSearchExpress()) {
processSearch(process);
} else if (index != null) {
if (hasWatchExpress()) {
processWatch(process);
} else {
processShow(process);
}
}
}
@Override
protected Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
}
return classNameMatcher;
}
@Override
protected Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
@Override
protected Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
return new TimeTunnelAdviceListener(this, process, GlobalOptions.verbose || this.verbose);
}
// 展示指定记录
private void processShow(CommandProcess process) {
RowAffect affect = new RowAffect();
try {
TimeFragment tf = timeFragmentMap.get(index);
if (null == tf) {
process.end(1, format("Time fragment[%d] does not exist.", index));
return;
}
TimeFragmentVO timeFragmentVO = createTimeFragmentVO(index, tf, expand);
TimeTunnelModel timeTunnelModel = new TimeTunnelModel()
.setTimeFragment(timeFragmentVO)
.setExpand(expand)
.setSizeLimit(sizeLimit);
process.appendResult(timeTunnelModel);
affect.rCnt(1);
process.appendResult(new RowAffectModel(affect));
process.end();
} catch (Throwable e) {
logger.warn("tt failed.", e);
process.end(1, e.getMessage() + ", visit " + LogUtil.loggingFile() + " for more detail");
}
}
// 查看记录信息
private void processWatch(CommandProcess process) {
RowAffect affect = new RowAffect();
try {
final TimeFragment tf = timeFragmentMap.get(index);
if (null == tf) {
process.end(1, format("Time fragment[%d] does not exist.", index));
return;
}
Advice advice = tf.getAdvice();
Object value = ExpressFactory.unpooledExpress(advice.getLoader()).bind(advice).get(watchExpress);
TimeTunnelModel timeTunnelModel = new TimeTunnelModel()
.setWatchValue(new ObjectVO(value, expand))
.setExpand(expand)
.setSizeLimit(sizeLimit);
process.appendResult(timeTunnelModel);
affect.rCnt(1);
process.appendResult(new RowAffectModel(affect));
process.end();
} catch (ExpressException e) {
logger.warn("tt failed.", e);
process.end(1, e.getMessage() + ", visit " + LogUtil.loggingFile() + " for more detail");
}
}
// do search timeFragmentMap
private void processSearch(CommandProcess process) {
RowAffect affect = new RowAffect();
try {
// 匹配的时间片段
Map<Integer, TimeFragment> matchingTimeSegmentMap = new LinkedHashMap<Integer, TimeFragment>();
for (Map.Entry<Integer, TimeFragment> entry : timeFragmentMap.entrySet()) {
int index = entry.getKey();
TimeFragment tf = entry.getValue();
Advice advice = tf.getAdvice();
// 搜索出匹配的时间片段
if ((ExpressFactory.threadLocalExpress(advice)).is(searchExpress)) {
matchingTimeSegmentMap.put(index, tf);
}
}
if (hasWatchExpress()) {
// 执行watchExpress
Map<Integer, ObjectVO> searchResults = new LinkedHashMap<Integer, ObjectVO>();
for (Map.Entry<Integer, TimeFragment> entry : matchingTimeSegmentMap.entrySet()) {
Object value = ExpressFactory.threadLocalExpress(entry.getValue().getAdvice()).get(watchExpress);
searchResults.put(entry.getKey(), new ObjectVO(value, expand));
}
TimeTunnelModel timeTunnelModel = new TimeTunnelModel()
.setWatchResults(searchResults)
.setExpand(expand)
.setSizeLimit(sizeLimit);
process.appendResult(timeTunnelModel);
} else {
// 单纯的列表格
List<TimeFragmentVO> timeFragmentList = createTimeTunnelVOList(matchingTimeSegmentMap);
process.appendResult(new TimeTunnelModel().setTimeFragmentList(timeFragmentList).setFirst(true));
}
affect.rCnt(matchingTimeSegmentMap.size());
process.appendResult(new RowAffectModel(affect));
process.end();
} catch (ExpressException e) {
logger.warn("tt failed.", e);
process.end(1, e.getMessage() + ", visit " + LogUtil.loggingFile() + " for more detail");
}
}
// 删除指定记录
private void processDelete(CommandProcess process) {
RowAffect affect = new RowAffect();
if (timeFragmentMap.remove(index) != null) {
affect.rCnt(1);
}
process.appendResult(new MessageModel(format("Time fragment[%d] successfully deleted.", index)));
process.appendResult(new RowAffectModel(affect));
process.end();
}
private void processDeleteAll(CommandProcess process) {
int count = timeFragmentMap.size();
RowAffect affect = new RowAffect(count);
timeFragmentMap.clear();
process.appendResult(new MessageModel("Time fragments are cleaned."));
process.appendResult(new RowAffectModel(affect));
process.end();
}
private void processList(CommandProcess process) {
RowAffect affect = new RowAffect();
List<TimeFragmentVO> timeFragmentList = createTimeTunnelVOList(timeFragmentMap);
process.appendResult(new TimeTunnelModel().setTimeFragmentList(timeFragmentList).setFirst(true));
affect.rCnt(timeFragmentMap.size());
process.appendResult(new RowAffectModel(affect));
process.end();
}
private List<TimeFragmentVO> createTimeTunnelVOList(Map<Integer, TimeFragment> timeFragmentMap) {
List<TimeFragmentVO> timeFragmentList = new ArrayList<TimeFragmentVO>(timeFragmentMap.size());
for (Map.Entry<Integer, TimeFragment> entry : timeFragmentMap.entrySet()) {
timeFragmentList.add(createTimeFragmentVO(entry.getKey(), entry.getValue(), expand));
}
return timeFragmentList;
}
public static TimeFragmentVO createTimeFragmentVO(Integer index, TimeFragment tf, Integer expand) {
Advice advice = tf.getAdvice();
String object = advice.getTarget() == null
? "NULL"
: "0x" + toHexString(advice.getTarget().hashCode());
return new TimeFragmentVO()
.setIndex(index)
.setTimestamp(tf.getGmtCreate())
.setCost(tf.getCost())
.setParams(ObjectVO.array(advice.getParams(), expand))
.setReturn(advice.isAfterReturning())
.setReturnObj(new ObjectVO(advice.getReturnObj(), expand))
.setThrow(advice.isAfterThrowing())
.setThrowExp(new ObjectVO(advice.getThrowExp(), expand))
.setObject(object)
.setClassName(advice.getClazz().getName())
.setMethodName(advice.getMethod().getName());
}
/**
* 重放指定记录
*/
private void processPlay(CommandProcess process) {
TimeFragment tf = timeFragmentMap.get(index);
if (null == tf) {
process.end(1, format("Time fragment[%d] does not exist.", index));
return;
}
Advice advice = tf.getAdvice();
ArthasMethod method = advice.getMethod();
boolean accessible = advice.getMethod().isAccessible();
try {
if (!accessible) {
method.setAccessible(true);
}
for (int i = 0; i < getReplayTimes(); i++) {
if (i > 0) {
//wait for the next execution
Thread.sleep(getReplayInterval());
if (!process.isRunning()) {
return;
}
}
long beginTime = System.nanoTime();
//copy from tt record
TimeFragmentVO replayResult = createTimeFragmentVO(index, tf, expand);
replayResult.setTimestamp(LocalDateTime.now())
.setCost(0)
.setReturn(false)
.setReturnObj(null)
.setThrow(false)
.setThrowExp(null);
try {
//execute successful
Object returnObj = method.invoke(advice.getTarget(), advice.getParams());
double cost = (System.nanoTime() - beginTime) / 1000000.0;
replayResult.setCost(cost)
.setReturn(true)
.setReturnObj(new ObjectVO(returnObj, expand));
} catch (Throwable t) {
//throw exp
double cost = (System.nanoTime() - beginTime) / 1000000.0;
replayResult.setCost(cost)
.setThrow(true)
.setThrowExp(new ObjectVO(t, expand));
}
TimeTunnelModel timeTunnelModel = new TimeTunnelModel()
.setReplayResult(replayResult)
.setReplayNo(i + 1)
.setExpand(expand)
.setSizeLimit(sizeLimit);
process.appendResult(timeTunnelModel);
}
process.end();
} catch (Throwable t) {
logger.warn("tt replay failed.", t);
process.end(-1, "tt replay failed");
} finally {
method.setAccessible(accessible);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceEntity.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceEntity.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.command.model.TraceModel;
import com.taobao.arthas.core.command.model.TraceTree;
import com.taobao.arthas.core.util.ThreadUtil;
/**
* 用于在ThreadLocal中传递的实体
* @author ralf0131 2017-01-05 14:05.
*/
public class TraceEntity {
protected TraceTree tree;
protected int deep;
public TraceEntity(ClassLoader loader) {
this.tree = createTraceTree(loader);
this.deep = 0;
}
private TraceTree createTraceTree(ClassLoader loader) {
return new TraceTree(ThreadUtil.getThreadNode(loader, Thread.currentThread()));
}
public TraceModel getModel() {
tree.trim();
return new TraceModel(tree.getRoot(), tree.getNodeCount());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/GroovyAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/GroovyAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.ScriptSupportCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
/**
* Groovy support has been completed dropped in Arthas 3.0 because of severer memory leak.
* @author beiwei30 on 01/12/2016.
*/
@Deprecated
public class GroovyAdviceListener extends AdviceListenerAdapter {
private ScriptSupportCommand.ScriptListener scriptListener;
private ScriptSupportCommand.Output output;
public GroovyAdviceListener(ScriptSupportCommand.ScriptListener scriptListener, CommandProcess process) {
this.scriptListener = scriptListener;
this.output = new CommandProcessAdaptor(process);
}
@Override
public void create() {
scriptListener.create(output);
}
@Override
public void destroy() {
scriptListener.destroy(output);
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
scriptListener.before(output, Advice.newForBefore(loader, clazz, method, target, args));
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
scriptListener.afterReturning(output, Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject));
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) throws Throwable {
scriptListener.afterThrowing(output, Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable));
}
private static class CommandProcessAdaptor implements ScriptSupportCommand.Output {
private CommandProcess process;
public CommandProcessAdaptor(CommandProcess process) {
this.process = process;
}
@Override
public ScriptSupportCommand.Output print(String string) {
process.write(string);
return this;
}
@Override
public ScriptSupportCommand.Output println(String string) {
process.write(string).write("\n");
return this;
}
@Override
public ScriptSupportCommand.Output finish() {
process.end();
return this;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/WatchAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/WatchAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AccessPoint;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.command.model.WatchModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import java.time.LocalDateTime;
/**
* @author beiwei30 on 29/11/2016.
*/
class WatchAdviceListener extends AdviceListenerAdapter {
private static final Logger logger = LoggerFactory.getLogger(WatchAdviceListener.class);
private final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
private WatchCommand command;
private CommandProcess process;
public WatchAdviceListener(WatchCommand command, CommandProcess process, boolean verbose) {
this.command = command;
this.process = process;
super.setVerbose(verbose);
}
private boolean isFinish() {
return command.isFinish() || !command.isBefore() && !command.isException() && !command.isSuccess();
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
// 开始计算本次方法调用耗时
threadLocalWatch.start();
if (command.isBefore()) {
watching(Advice.newForBefore(loader, clazz, method, target, args));
}
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
Advice advice = Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject);
if (command.isSuccess()) {
watching(advice);
}
finishing(advice);
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) {
Advice advice = Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable);
if (command.isException()) {
watching(advice);
}
finishing(advice);
}
private void finishing(Advice advice) {
if (isFinish()) {
watching(advice);
}
}
private void watching(Advice advice) {
try {
// 本次调用的耗时
double cost = threadLocalWatch.costInMillis();
boolean conditionResult = isConditionMet(command.getConditionExpress(), advice, cost);
if (this.isVerbose()) {
process.write("Condition express: " + command.getConditionExpress() + " , result: " + conditionResult + "\n");
}
if (conditionResult) {
// TODO: concurrency issues for process.write
Object value = getExpressionResult(command.getExpress(), advice, cost);
WatchModel model = new WatchModel();
model.setTs(LocalDateTime.now());
model.setCost(cost);
model.setValue(new ObjectVO(value, command.getExpand()));
model.setSizeLimit(command.getSizeLimit());
model.setClassName(advice.getClazz().getName());
model.setMethodName(advice.getMethod().getName());
if (advice.isBefore()) {
model.setAccessPoint(AccessPoint.ACCESS_BEFORE.getKey());
} else if (advice.isAfterReturning()) {
model.setAccessPoint(AccessPoint.ACCESS_AFTER_RETUNING.getKey());
} else if (advice.isAfterThrowing()) {
model.setAccessPoint(AccessPoint.ACCESS_AFTER_THROWING.getKey());
}
process.appendResult(model);
process.times().incrementAndGet();
if (isLimitExceeded(command.getNumberOfLimit(), process.times().get())) {
abortProcess(process, command.getNumberOfLimit());
}
}
} catch (Throwable e) {
logger.warn("watch failed.", e);
process.end(-1, "watch failed, condition is: " + command.getConditionExpress() + ", express is: "
+ command.getExpress() + ", " + e.getMessage() + ", visit " + LogUtil.loggingFile()
+ " for more details.");
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/MemoryCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/MemoryCommand.java | package com.taobao.arthas.core.command.monitor200;
import static com.taobao.arthas.core.command.model.MemoryEntryVO.TYPE_BUFFER_POOL;
import static com.taobao.arthas.core.command.model.MemoryEntryVO.TYPE_HEAP;
import static com.taobao.arthas.core.command.model.MemoryEntryVO.TYPE_NON_HEAP;
import java.lang.management.BufferPoolMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryType;
import java.lang.management.MemoryUsage;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.MemoryEntryVO;
import com.taobao.arthas.core.command.model.MemoryModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Summary;
/**
* @author hengyunabc 2022-03-01
*/
@Name("memory")
@Summary("Display jvm memory info.")
@Description(Constants.EXAMPLE + " memory\n" + Constants.WIKI + Constants.WIKI_HOME + "memory")
public class MemoryCommand extends AnnotatedCommand {
@Override
public void process(CommandProcess process) {
MemoryModel result = new MemoryModel();
result.setMemoryInfo(memoryInfo());
process.appendResult(result);
process.end();
}
static Map<String, List<MemoryEntryVO>> memoryInfo() {
List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
Map<String, List<MemoryEntryVO>> memoryInfoMap = new LinkedHashMap<String, List<MemoryEntryVO>>();
// heap
MemoryUsage heapMemoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
List<MemoryEntryVO> heapMemEntries = new ArrayList<MemoryEntryVO>();
heapMemEntries.add(createMemoryEntryVO(TYPE_HEAP, TYPE_HEAP, heapMemoryUsage));
for (MemoryPoolMXBean poolMXBean : memoryPoolMXBeans) {
if (MemoryType.HEAP.equals(poolMXBean.getType())) {
MemoryUsage usage = getUsage(poolMXBean);
if (usage != null) {
String poolName = StringUtils.beautifyName(poolMXBean.getName());
heapMemEntries.add(createMemoryEntryVO(TYPE_HEAP, poolName, usage));
}
}
}
memoryInfoMap.put(TYPE_HEAP, heapMemEntries);
// non-heap
MemoryUsage nonHeapMemoryUsage = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
List<MemoryEntryVO> nonheapMemEntries = new ArrayList<MemoryEntryVO>();
nonheapMemEntries.add(createMemoryEntryVO(TYPE_NON_HEAP, TYPE_NON_HEAP, nonHeapMemoryUsage));
for (MemoryPoolMXBean poolMXBean : memoryPoolMXBeans) {
if (MemoryType.NON_HEAP.equals(poolMXBean.getType())) {
MemoryUsage usage = getUsage(poolMXBean);
if (usage != null) {
String poolName = StringUtils.beautifyName(poolMXBean.getName());
nonheapMemEntries.add(createMemoryEntryVO(TYPE_NON_HEAP, poolName, usage));
}
}
}
memoryInfoMap.put(TYPE_NON_HEAP, nonheapMemEntries);
addBufferPoolMemoryInfo(memoryInfoMap);
return memoryInfoMap;
}
private static MemoryUsage getUsage(MemoryPoolMXBean memoryPoolMXBean) {
try {
return memoryPoolMXBean.getUsage();
} catch (InternalError e) {
// Defensive for potential InternalError with some specific JVM options. Based on its Javadoc,
// MemoryPoolMXBean.getUsage() should return null, not throwing InternalError, so it seems to be a JVM bug.
return null;
}
}
private static void addBufferPoolMemoryInfo(Map<String, List<MemoryEntryVO>> memoryInfoMap) {
try {
List<MemoryEntryVO> bufferPoolMemEntries = new ArrayList<MemoryEntryVO>();
@SuppressWarnings("rawtypes")
Class bufferPoolMXBeanClass = Class.forName("java.lang.management.BufferPoolMXBean");
@SuppressWarnings("unchecked")
List<BufferPoolMXBean> bufferPoolMXBeans = ManagementFactory.getPlatformMXBeans(bufferPoolMXBeanClass);
for (BufferPoolMXBean mbean : bufferPoolMXBeans) {
long used = mbean.getMemoryUsed();
long total = mbean.getTotalCapacity();
bufferPoolMemEntries
.add(new MemoryEntryVO(TYPE_BUFFER_POOL, mbean.getName(), used, total, Long.MIN_VALUE));
}
memoryInfoMap.put(TYPE_BUFFER_POOL, bufferPoolMemEntries);
} catch (ClassNotFoundException e) {
// ignore
}
}
private static MemoryEntryVO createMemoryEntryVO(String type, String name, MemoryUsage memoryUsage) {
return new MemoryEntryVO(type, name, memoryUsage.getUsed(), memoryUsage.getCommitted(), memoryUsage.getMax());
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.advisor.InvokeTraceable;
import com.taobao.arthas.core.shell.command.CommandProcess;
/**
* @author beiwei30 on 29/11/2016.
*/
public class TraceAdviceListener extends AbstractTraceAdviceListener implements InvokeTraceable {
/**
* Constructor
*/
public TraceAdviceListener(TraceCommand command, CommandProcess process, boolean verbose) {
super(command, process);
super.setVerbose(verbose);
}
/**
* trace 会在被观测的方法体中，在每个方法调用前后插入字节码，所以方法调用开始，结束，抛异常的时候，都会回调下面的接口
*/
@Override
public void invokeBeforeTracing(ClassLoader classLoader, String tracingClassName, String tracingMethodName, String tracingMethodDesc, int tracingLineNumber)
throws Throwable {
// normalize className later
threadLocalTraceEntity(classLoader).tree.begin(tracingClassName, tracingMethodName, tracingLineNumber, true);
}
@Override
public void invokeAfterTracing(ClassLoader classLoader, String tracingClassName, String tracingMethodName, String tracingMethodDesc, int tracingLineNumber)
throws Throwable {
threadLocalTraceEntity(classLoader).tree.end();
}
@Override
public void invokeThrowTracing(ClassLoader classLoader, String tracingClassName, String tracingMethodName, String tracingMethodDesc, int tracingLineNumber)
throws Throwable {
threadLocalTraceEntity(classLoader).tree.end(true);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* 监控请求命令<br/>
* @author vlinux
*/
@Name("monitor")
@Summary("Monitor method execution statistics, e.g. total/success/failure count, average rt, fail rate, etc. ")
@Description("\nExamples:\n" +
" monitor org.apache.commons.lang.StringUtils isBlank\n" +
" monitor org.apache.commons.lang.StringUtils isBlank -c 5\n" +
" monitor org.apache.commons.lang.StringUtils isBlank params[0]!=null\n" +
" monitor -b org.apache.commons.lang.StringUtils isBlank params[0]!=null\n" +
" monitor -E org\\.apache\\.commons\\.lang\\.StringUtils isBlank\n" +
Constants.WIKI + Constants.WIKI_HOME + "monitor")
public class MonitorCommand extends EnhancerCommand {
private String classPattern;
private String methodPattern;
private String conditionExpress;
private int cycle = 60;
private boolean isRegEx = false;
private int numberOfLimit = 100;
private boolean isBefore = false;
@Argument(argName = "class-pattern", index = 0)
@Description("Path and classname of Pattern Matching")
public void setClassPattern(String classPattern) {
this.classPattern = StringUtils.normalizeClassName(classPattern);
}
@Argument(argName = "method-pattern", index = 1)
@Description("Method of Pattern Matching")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(argName = "condition-express", index = 2, required = false)
@Description(Constants.CONDITION_EXPRESS)
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
@Option(shortName = "c", longName = "cycle")
@Description("The monitor interval (in seconds), 60 seconds by default")
public void setCycle(int cycle) {
this.cycle = cycle;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "n", longName = "limits")
@Description("Threshold of execution times")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
@Option(shortName = "b", longName = "before", flag = true)
@Description("Evaluate the condition-express before method invoke")
public void setBefore(boolean before) {
isBefore = before;
}
public String getClassPattern() {
return classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public String getConditionExpress() {
return conditionExpress;
}
public int getCycle() {
return cycle;
}
public boolean isRegEx() {
return isRegEx;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
public boolean isBefore() {
return isBefore;
}
@Override
protected Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
}
return classNameMatcher;
}
@Override
protected Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
@Override
protected Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
final AdviceListener listener = new MonitorAdviceListener(this, process, GlobalOptions.verbose || this.verbose);
/*
* 通过handle回调，在suspend时停止timer，resume时重启timer
*/
process.suspendHandler(new Handler<Void>() {
@Override
public void handle(Void event) {
listener.destroy();
}
});
process.resumeHandler(new Handler<Void>() {
@Override
public void handle(Void event) {
listener.create();
}
});
return listener;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/GroovyScriptCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/GroovyScriptCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.ScriptSupportCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Hidden;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* Groovy support has been completed dropped in Arthas 3.0 because of severer memory leak.
* 脚本增强命令
*
* @author vlinux on 15/5/31.
*/
@Name("groovy")
@Hidden
@Summary("Enhanced Groovy")
@Description("Examples:\n" +
" groovy -E org\\.apache\\.commons\\.lang\\.StringUtils isBlank /tmp/watch.groovy\n" +
" groovy org.apache.commons.lang.StringUtils isBlank /tmp/watch.groovy\n" +
" groovy *StringUtils isBlank /tmp/watch.groovy\n" +
"\n" +
"WIKI:\n" +
" middleware-container/arthas/wikis/cmds/groovy")
@Deprecated
public class GroovyScriptCommand extends EnhancerCommand implements ScriptSupportCommand {
private String classPattern;
private String methodPattern;
private String scriptFilepath;
private boolean isRegEx = false;
@Argument(index = 0, argName = "class-pattern")
@Description("Path and classname of Pattern Matching")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Argument(index = 1, argName = "method-pattern")
@Description("Method of Pattern Matching")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(index = 2, argName = "script-filepath")
@Description("Filepath of Groovy script")
public void setScriptFilepath(String scriptFilepath) {
this.scriptFilepath = scriptFilepath;
}
@Option(shortName = "E", longName = "regex")
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
public String getClassPattern() {
return classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public String getScriptFilepath() {
return scriptFilepath;
}
public boolean isRegEx() {
return isRegEx;
}
@Override
protected Matcher getClassNameMatcher() {
throw new UnsupportedOperationException("groovy command is not supported yet!");
}
@Override
protected Matcher getClassNameExcludeMatcher() {
throw new UnsupportedOperationException("groovy command is not supported yet!");
}
@Override
protected Matcher getMethodNameMatcher() {
throw new UnsupportedOperationException("groovy command is not supported yet!");
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
throw new UnsupportedOperationException("groovy command is not supported yet!");
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.model.MonitorModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;
import static com.taobao.arthas.core.util.ArthasCheckUtils.isEquals;
/**
* 输出的内容格式为:<br/>
* <style type="text/css">
* table, th, td {
* borders:1px solid #cccccc;
* borders-collapse:collapse;
* }
* </style>
* <table>
* <tr>
* <th>时间戳</th>
* <th>统计周期(s)</th>
* <th>类全路径</th>
* <th>方法名</th>
* <th>调用总次数</th>
* <th>成功次数</th>
* <th>失败次数</th>
* <th>平均耗时(ms)</th>
* <th>失败率</th>
* </tr>
* <tr>
* <td>2012-11-07 05:00:01</td>
* <td>120</td>
* <td>com.taobao.item.ItemQueryServiceImpl</td>
* <td>queryItemForDetail</td>
* <td>1500</td>
* <td>1000</td>
* <td>500</td>
* <td>15</td>
* <td>30%</td>
* </tr>
* <tr>
* <td>2012-11-07 05:00:01</td>
* <td>120</td>
* <td>com.taobao.item.ItemQueryServiceImpl</td>
* <td>queryItemById</td>
* <td>900</td>
* <td>900</td>
* <td>0</td>
* <td>7</td>
* <td>0%</td>
* </tr>
* </table>
*
* @author beiwei30 on 28/11/2016.
*/
class MonitorAdviceListener extends AdviceListenerAdapter {
// 输出定时任务
private Timer timer;
private static final Logger logger = LoggerFactory.getLogger(MonitorAdviceListener.class);
// 监控数据
private ConcurrentHashMap<Key, AtomicReference<MonitorData>> monitorData = new ConcurrentHashMap<Key, AtomicReference<MonitorData>>();
private final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
private final ThreadLocal<Boolean> conditionResult = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return true;
}
};
private MonitorCommand command;
private CommandProcess process;
MonitorAdviceListener(MonitorCommand command, CommandProcess process, boolean verbose) {
this.command = command;
this.process = process;
super.setVerbose(verbose);
}
@Override
public synchronized void create() {
if (timer == null) {
timer = new Timer("Timer-for-arthas-monitor-" + process.session().getSessionId(), true);
timer.scheduleAtFixedRate(new MonitorTimer(monitorData, process, command.getNumberOfLimit()),
0, command.getCycle() * 1000L);
}
}
@Override
public synchronized void destroy() {
if (null != timer) {
timer.cancel();
timer = null;
}
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
threadLocalWatch.start();
if (!StringUtils.isEmpty(this.command.getConditionExpress()) && command.isBefore()) {
Advice advice = Advice.newForBefore(loader, clazz, method, target, args);
long cost = threadLocalWatch.cost();
this.conditionResult.set(isConditionMet(this.command.getConditionExpress(), advice, cost));
//重新计算执行方法的耗时(排除执行condition-express耗时)
threadLocalWatch.start();
}
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target,
Object[] args, Object returnObject) throws Throwable {
finishing(clazz, method, false, Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject));
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target,
Object[] args, Throwable throwable) {
finishing(clazz, method, true, Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable));
}
private void finishing(Class<?> clazz, ArthasMethod method, boolean isThrowing, Advice advice) {
double cost = threadLocalWatch.costInMillis();
if (command.isBefore()) {
if (!this.conditionResult.get()) {
return;
}
} else {
try {
//不满足condition-express的不纳入统计
if (!isConditionMet(this.command.getConditionExpress(), advice, cost)) {
return;
}
} catch (ExpressException e) {
//condition-express执行错误的不纳入统计
logger.warn("monitor execute condition-express failed.", e);
return;
}
}
final Key key = new Key(clazz.getName(), method.getName());
while (true) {
AtomicReference<MonitorData> value = monitorData.get(key);
if (null == value) {
monitorData.putIfAbsent(key, new AtomicReference<MonitorData>(new MonitorData()));
continue;
}
while (true) {
MonitorData oData = value.get();
MonitorData nData = new MonitorData();
nData.setCost(oData.getCost() + cost);
nData.setTimestamp(LocalDateTime.now());
if (isThrowing) {
nData.setFailed(oData.getFailed() + 1);
nData.setSuccess(oData.getSuccess());
} else {
nData.setFailed(oData.getFailed());
nData.setSuccess(oData.getSuccess() + 1);
}
nData.setTotal(oData.getTotal() + 1);
if (value.compareAndSet(oData, nData)) {
break;
}
}
break;
}
}
private class MonitorTimer extends TimerTask {
private Map<Key, AtomicReference<MonitorData>> monitorData;
private CommandProcess process;
private int limit;
MonitorTimer(Map<Key, AtomicReference<MonitorData>> monitorData, CommandProcess process, int limit) {
this.monitorData = monitorData;
this.process = process;
this.limit = limit;
}
@Override
public void run() {
if (monitorData.isEmpty()) {
return;
}
// 超过次数上限，则不再输出，命令终止
if (process.times().getAndIncrement() >= limit) {
this.cancel();
abortProcess(process, limit);
return;
}
List<MonitorData> monitorDataList = new ArrayList<MonitorData>(monitorData.size());
for (Map.Entry<Key, AtomicReference<MonitorData>> entry : monitorData.entrySet()) {
final AtomicReference<MonitorData> value = entry.getValue();
MonitorData data;
while (true) {
data = value.get();
//swap monitor data to new instance
if (value.compareAndSet(data, new MonitorData())) {
break;
}
}
if (null != data) {
data.setClassName(entry.getKey().getClassName());
data.setMethodName(entry.getKey().getMethodName());
monitorDataList.add(data);
}
}
process.appendResult(new MonitorModel(monitorDataList));
}
}
/**
* 数据监控用的Key
*
* @author vlinux
*/
private static class Key {
private final String className;
private final String methodName;
Key(String className, String behaviorName) {
this.className = className;
this.methodName = behaviorName;
}
public String getClassName() {
return className;
}
public String getMethodName() {
return methodName;
}
@Override
public int hashCode() {
return className.hashCode() + methodName.hashCode();
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Key)) {
return false;
}
Key okey = (Key) obj;
return isEquals(okey.className, className) && isEquals(okey.methodName, methodName);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeFragment.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeFragment.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.advisor.Advice;
import java.time.LocalDateTime;
/**
* 时间碎片
*/
class TimeFragment {
public TimeFragment(Advice advice, LocalDateTime gmtCreate, double cost) {
this.advice = advice;
this.gmtCreate = gmtCreate;
this.cost = cost;
}
private final Advice advice;
private final LocalDateTime gmtCreate;
private final double cost;
public Advice getAdvice() {
return advice;
}
public LocalDateTime getGmtCreate() {
return gmtCreate;
}
public double getCost() {
return cost;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/ProfilerCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/ProfilerCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.CodeSource;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.IOUtils;
import com.taobao.arthas.common.OSUtils;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.ProfilerModel;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import arthas.VmTool;
import one.profiler.AsyncProfiler;
import one.profiler.Counter;
/**
* https://github.com/async-profiler/async-profiler/blob/master/docs/ProfilerOptions.md 具体参数说明，以及哪些参数可以传递给 async-profiler agent
* @author hengyunabc 2019-10-31
*
*/
//@formatter:off
@Name("profiler")
@Summary("Async Profiler. https://github.com/jvm-profiling-tools/async-profiler")
@Description(Constants.EXAMPLE
+ " profiler start\n"
+ " profiler stop\n"
+ " profiler list # list all supported events\n"
+ " profiler actions # list all supported actions\n"
+ " profiler start --event alloc\n"
+ " profiler start --timeout 300s"
+ " profiler start --loop 300s -f /tmp/result-%t.html"
+ " profiler start --duration 300"
+ " profiler stop --format html # output file format, support flat[=N]|traces[=N]|collapsed|flamegraph|tree|jfr\n"
+ " profiler stop --file /tmp/result.html\n"
+ " profiler stop --threads \n"
+ " profiler stop --include 'java/*' --include 'com/demo/*' --exclude '*Unsafe.park*'\n"
+ " profiler status\n"
+ " profiler resume # Start or resume profiling without resetting collected data.\n"
+ " profiler getSamples # Get the number of samples collected during the profiling session\n"
+ " profiler dumpFlat # Dump flat profile, i.e. the histogram of the hottest methods\n"
+ " profiler dumpCollapsed # Dump profile in 'collapsed stacktraces' format\n"
+ " profiler dumpTraces # Dump collected stack traces\n"
+ " profiler execute 'stop,file=/tmp/result.html' # Execute an agent-compatible profiling command\n"
+ Constants.WIKI + Constants.WIKI_HOME + "profiler")
//@formatter:on
public class ProfilerCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(ProfilerCommand.class);
// Track if a file was specified during profiler start
private static String fileSpecifiedAtStart = null;
// TODO start 时，没指定 file， 是否在 stop 时，能生成 html 或者 jfr 不？
private String action;
private String actionArg;
/**
* which event to trace (cpu, wall, cache-misses, etc.)
*/
private String event;
/**
* profile allocations with BYTES interval
* according to async-profiler README, alloc may contains non-numeric characters
*/
private String alloc;
/**
* build allocation profile from live objects only
*/
private boolean live;
/**
* profile contended locks longer than DURATION ns
* according to async-profiler README, alloc may contains non-numeric characters
*/
private String lock;
/**
* start Java Flight Recording with the given config along with the profiler
*/
private String jfrsync;
/**
* output file name for dumping
*/
private String file;
/**
* output file format, default value is html.
*/
private String format;
/**
* sampling interval in ns (default: 10'000'000, i.e. 10 ms)
*/
private Long interval;
/**
* maximum Java stack depth (default: 2048)
*/
private Integer jstackdepth;
/**
* wall clock profiling interval
*/
private Long wall;
/**
* profile different threads separately
*/
private boolean threads;
/**
* group threads by scheduling policy
*/
private boolean sched;
/**
* how to collect C stack frames in addition to Java stack
* MODE is 'fp' (Frame Pointer), 'dwarf', 'lbr' (Last Branch Record) or 'no'
*/
private String cstack;
/**
* use simple class names instead of FQN
*/
private boolean simple;
/**
* print method signatures
*/
private boolean sig;
/**
* annotate Java methods
*/
private boolean ann;
/**
* prepend library names
*/
private boolean lib;
/**
* include only user-mode events
*/
private boolean alluser;
/**
* run profiling for <duration> seconds
*/
private Long duration;
/**
* include stack traces containing PATTERN
*/
private List<String> includes;
/**
* exclude stack traces containing PATTERN
*/
private List<String> excludes;
/**
* automatically start profiling when the specified native function is executed.
*/
private String begin;
/**
* automatically stop profiling when the specified native function is executed.
*/
private String end;
/**
* time-to-safepoint profiling.
* An alias for --begin SafepointSynchronize::begin --end RuntimeService::record_safepoint_synchronized
*/
private boolean ttsp;
/**
* FlameGraph title
*/
private String title;
/**
* FlameGraph minimum frame width in percent
*/
private String minwidth;
/**
* generate stack-reversed FlameGraph / Call tree
*/
private boolean reverse;
/**
* count the total value (time, bytes, etc.) instead of samples
*/
private boolean total;
/**
* approximate size of JFR chunk in bytes (default: 100 MB)
*/
private String chunksize;
/**
* duration of JFR chunk in seconds (default: 1 hour)
*/
private String chunktime;
/**
* run profiler in a loop (continuous profiling)
*/
private String loop;
/**
* automatically stop profiler at TIME (absolute or relative)
*/
private String timeout;
/**
* Features enabled for profiling
*/
private String features;
/**
* Profiling signal to use
*/
private String signal;
/*
* Clock source for sampling timestamps: monotonic or tsc
*/
private String clock;
/*
* Normalize method names by removing unique numerical suffixes from lambda classes.
*/
private boolean norm;
private static String libPath;
private static AsyncProfiler profiler = null;
static {
String profilerSoPath = null;
if (OSUtils.isMac()) {
// FAT_BINARY support both x86_64/arm64
profilerSoPath = "async-profiler/libasyncProfiler-mac.dylib";
}
if (OSUtils.isLinux()) {
if (OSUtils.isX86_64()) {
profilerSoPath = "async-profiler/libasyncProfiler-linux-x64.so";
} else if (OSUtils.isArm64()) {
profilerSoPath = "async-profiler/libasyncProfiler-linux-arm64.so";
}
}
if (profilerSoPath != null) {
CodeSource codeSource = ProfilerCommand.class.getProtectionDomain().getCodeSource();
if (codeSource != null) {
try {
File bootJarPath = new File(codeSource.getLocation().toURI().getSchemeSpecificPart());
File soFile = new File(bootJarPath.getParentFile(), profilerSoPath);
if (soFile.exists()) {
libPath = soFile.getAbsolutePath();
}
} catch (Throwable e) {
logger.error("can not find libasyncProfiler so", e);
}
}
}
}
@Argument(argName = "action", index = 0, required = true)
@Description("Action to execute")
public void setAction(String action) {
this.action = action;
}
@Argument(argName = "actionArg", index = 1, required = false)
@Description("Attribute name pattern.")
public void setActionArg(String actionArg) {
this.actionArg = actionArg;
}
@Option(shortName = "i", longName = "interval")
@Description("sampling interval in ns (default: 10'000'000, i.e. 10 ms)")
@DefaultValue("10000000")
public void setInterval(long interval) {
this.interval = interval;
}
@Option(shortName = "j", longName = "jstackdepth")
@Description("maximum Java stack depth (default: 2048)")
public void setJstackdepth(int jstackdepth) {
this.jstackdepth = jstackdepth;
}
@Option(shortName = "f", longName = "file")
@Description("dump output to <filename>, if ends with html or jfr, content format can be infered")
public void setFile(String file) {
this.file = file;
}
@Option(shortName = "o", longName = "format")
@Description("dump output content format(flat[=N]|traces[=N]|collapsed|flamegraph|tree|jfr)")
public void setFormat(String format) {
// only for backward compatibility
if ("html".equals(format)) {
format = "flamegraph";
}
this.format = format;
}
@Option(shortName = "e", longName = "event")
@Description("which event to trace (cpu, alloc, lock, cache-misses etc.), default value is cpu")
@DefaultValue("cpu")
public void setEvent(String event) {
this.event = event;
}
@Option(longName = "alloc")
@Description("allocation profiling interval in bytes")
public void setAlloc(String alloc) {
this.alloc = alloc;
}
@Option(longName = "live", flag = true)
@Description("build allocation profile from live objects only")
public void setLive(boolean live) {
this.live = live;
}
@Option(longName = "lock")
@Description("lock profiling threshold in nanoseconds")
public void setLock(String lock) {
this.lock = lock;
}
@Option(longName = "jfrsync")
@Description("Start Java Flight Recording with the given config along with the profiler. "
+ "Accepts a predefined profile name, a path to a .jfc file, or a list of JFR events starting with '+'. ")
public void setJfrsync(String jfrsync) {
this.jfrsync = jfrsync;
}
@Option(longName = "wall")
@Description("wall clock profiling interval in milliseconds(recommended: 200)")
public void setWall(Long wall) {
this.wall = wall;
}
@Option(shortName = "t", longName = "threads", flag = true)
@Description("profile different threads separately")
public void setThreads(boolean threads) {
this.threads = threads;
}
@Option(shortName = "F", longName = "features")
@Description("Features enabled for profiling")
public void setFeatures(String features) {
this.features = features;
}
@Option(longName = "signal")
@Description("Set the profiling signal to use")
public void setSignal(String signal) {
this.signal = signal;
}
@Option(longName = "clock")
@Description("Clock source for sampling timestamps: monotonic or tsc")
public void setClock(String clock) {
this.clock = clock;
}
@Option(longName = "norm", flag = true)
@Description("Normalize method names by removing unique numerical suffixes from lambda classes.")
public void setNorm(boolean norm) {
this.norm = norm;
}
@Option(longName = "sched", flag = true)
@Description("group threads by scheduling policy")
public void setSched(boolean sched) {
this.sched = sched;
}
@Option(longName = "cstack")
@Description("how to traverse C stack: fp|dwarf|lbr|no")
public void setCstack(String cstack) {
this.cstack = cstack;
}
@Option(shortName = "s", flag = true)
@Description("use simple class names instead of FQN")
public void setSimple(boolean simple) {
this.simple = simple;
}
@Option(shortName = "g", flag = true)
@Description("print method signatures")
public void setSig(boolean sig) {
this.sig = sig;
}
@Option(shortName = "a", flag = true)
@Description("annotate Java methods")
public void setAnn(boolean ann) {
this.ann = ann;
}
@Option(shortName = "l", flag = true)
@Description("prepend library names")
public void setLib(boolean lib) {
this.lib = lib;
}
@Option(longName = "all-user", flag = true)
@Description("include only user-mode events")
public void setAlluser(boolean alluser) {
this.alluser = alluser;
}
@Option(shortName = "d", longName = "duration")
@Description("run profiling for <duration> seconds")
public void setDuration(long duration) {
this.duration = duration;
}
@Option(shortName = "I", longName = "include")
@Description("include stack traces containing PATTERN, for example: 'java/*'")
public void setInclude(List<String> includes) {
this.includes = includes;
}
@Option(shortName = "X", longName = "exclude")
@Description("exclude stack traces containing PATTERN, for example: '*Unsafe.park*'")
public void setExclude(List<String> excludes) {
this.excludes = excludes;
}
@Option(longName = "begin")
@Description("automatically start profiling when the specified native function is executed")
public void setBegin(String begin) {
this.begin = begin;
}
@Option(longName = "end")
@Description("automatically stop profiling when the specified native function is executed")
public void setEnd(String end) {
this.end = end;
}
@Option(longName = "ttsp", flag = true)
@Description("time-to-safepoint profiling. "
+ "An alias for --begin SafepointSynchronize::begin --end RuntimeService::record_safepoint_synchronized")
public void setTtsp(boolean ttsp) {
this.ttsp = ttsp;
}
@Option(longName = "title")
@Description("FlameGraph title")
public void setTitle(String title) {
// escape HTML special characters
// and escape comma to avoid conflicts with JVM TI
title = title.replace("&", "&")
.replace("<", "<")
.replace(">", ">")
.replace("\"", """)
.replace("'", "'")
.replace(",", ",");
this.title = title;
}
@Option(longName = "minwidth")
@Description("FlameGraph minimum frame width in percent")
public void setMinwidth(String minwidth) {
this.minwidth = minwidth;
}
@Option(longName = "reverse", flag = true)
@Description("generate stack-reversed FlameGraph / Call tree")
public void setReverse(boolean reverse) {
this.reverse = reverse;
}
@Option(longName = "total", flag = true)
@Description("count the total value (time, bytes, etc.) instead of samples")
public void setTotal(boolean total) {
this.total = total;
}
@Option(longName = "chunksize")
@Description("approximate size limits for a single JFR chunk in bytes (default: 100 MB) or other units")
public void setChunksize(String chunksize) {
this.chunksize = chunksize;
}
@Option(longName = "chunktime")
@Description("approximate time limits for a single JFR chunk in second (default: 1 hour) or other units")
public void setChunktime(String chunktime) {
this.chunktime = chunktime;
}
@Option(longName = "loop")
@Description("run profiler in a loop (continuous profiling)")
public void setLoop(String loop) {
this.loop = loop;
}
@Option(longName = "timeout")
@Description("automatically stop profiler at TIME (absolute or relative)")
public void setTimeout(String timeout) {
this.timeout = timeout;
}
private AsyncProfiler profilerInstance() {
if (profiler != null) {
return profiler;
}
// try to load from special path
if (ProfilerAction.load.toString().equals(action)) {
profiler = AsyncProfiler.getInstance(this.actionArg);
}
if (libPath != null) {
// load from arthas directory
// 尝试把lib文件复制到临时文件里，避免多次attach时出现 Native Library already loaded in another classloader
FileOutputStream tmpLibOutputStream = null;
FileInputStream libInputStream = null;
try {
File tmpLibFile = File.createTempFile(VmTool.JNI_LIBRARY_NAME, null);
tmpLibOutputStream = new FileOutputStream(tmpLibFile);
libInputStream = new FileInputStream(libPath);
IOUtils.copy(libInputStream, tmpLibOutputStream);
libPath = tmpLibFile.getAbsolutePath();
logger.debug("copy {} to {}", libPath, tmpLibFile);
} catch (Throwable e) {
logger.error("try to copy lib error! libPath: {}", libPath, e);
} finally {
IOUtils.close(libInputStream);
IOUtils.close(tmpLibOutputStream);
}
profiler = AsyncProfiler.getInstance(libPath);
} else {
if (OSUtils.isLinux() || OSUtils.isMac()) {
throw new IllegalStateException("Can not find libasyncProfiler so, please check the arthas directory.");
} else {
throw new IllegalStateException("Current OS do not support AsyncProfiler, Only support Linux/Mac.");
}
}
return profiler;
}
/**
* https://github.com/async-profiler/async-profiler/blob/v3.0/src/arguments.cpp#L131
*/
public enum ProfilerAction {
// start, resume, stop, dump, check, status, meminfo, list,
start, resume, stop, dump, check, status, meminfo, list,
version,
load,
execute,
dumpCollapsed, dumpFlat, dumpTraces, getSamples,
actions
}
private String executeArgs(ProfilerAction action) {
StringBuilder sb = new StringBuilder();
final char COMMA = ',';
// start - start profiling
// resume - start or resume profiling without resetting collected data
// stop - stop profiling
sb.append(action).append(COMMA);
if (this.event != null) {
sb.append("event=").append(this.event).append(COMMA);
}
if (this.alloc!= null) {
sb.append("alloc=").append(this.alloc).append(COMMA);
}
if (this.live) {
sb.append("live").append(COMMA);
}
if (this.lock!= null) {
sb.append("lock=").append(this.lock).append(COMMA);
}
if (this.jfrsync != null) {
this.format = "jfr";
sb.append("jfrsync=").append(this.jfrsync).append(COMMA);
}
if (this.file != null) {
sb.append("file=").append(this.file).append(COMMA);
}
if (this.format != null) {
sb.append(this.format).append(COMMA);
}
if (this.interval != null) {
sb.append("interval=").append(this.interval).append(COMMA);
}
if (this.features != null) {
sb.append("features=").append(this.features).append(COMMA);
}
if (this.signal != null) {
sb.append("signal=").append(this.signal).append(COMMA);
}
if (this.clock != null) {
sb.append("clock=").append(this.clock).append(COMMA);
}
if (this.jstackdepth != null) {
sb.append("jstackdepth=").append(this.jstackdepth).append(COMMA);
}
if (this.threads) {
sb.append("threads").append(COMMA);
}
if (this.sched) {
sb.append("sched").append(COMMA);
}
if (this.cstack != null) {
sb.append("cstack=").append(this.cstack).append(COMMA);
}
if (this.simple) {
sb.append("simple").append(COMMA);
}
if (this.sig) {
sb.append("sig").append(COMMA);
}
if (this.ann) {
sb.append("ann").append(COMMA);
}
if (this.lib) {
sb.append("lib").append(COMMA);
}
if (this.alluser) {
sb.append("alluser").append(COMMA);
}
if (this.norm) {
sb.append("norm").append(COMMA);
}
if (this.includes != null) {
for (String include : includes) {
sb.append("include=").append(include).append(COMMA);
}
}
if (this.excludes != null) {
for (String exclude : excludes) {
sb.append("exclude=").append(exclude).append(COMMA);
}
}
if (this.ttsp) {
this.begin = "SafepointSynchronize::begin";
this.end = "RuntimeService::record_safepoint_synchronized";
}
if (this.begin != null) {
sb.append("begin=").append(this.begin).append(COMMA);
}
if (this.end != null) {
sb.append("end=").append(this.end).append(COMMA);
}
if (this.wall != null) {
sb.append("wall=").append(this.wall).append(COMMA);
}
if (this.title != null) {
sb.append("title=").append(this.title).append(COMMA);
}
if (this.minwidth != null) {
sb.append("minwidth=").append(this.minwidth).append(COMMA);
}
if (this.reverse) {
sb.append("reverse").append(COMMA);
}
if (this.total) {
sb.append("total").append(COMMA);
}
if (this.chunksize != null) {
sb.append("chunksize=").append(this.chunksize).append(COMMA);
}
if (this.chunktime!= null) {
sb.append("chunktime=").append(this.chunktime).append(COMMA);
}
if (this.loop != null) {
sb.append("loop=").append(this.loop).append(COMMA);
}
if (this.timeout != null) {
sb.append("timeout=").append(this.timeout).append(COMMA);
}
return sb.toString();
}
private static String execute(AsyncProfiler asyncProfiler, String arg)
throws IllegalArgumentException, IOException {
logger.info("profiler execute args: {}", arg);
String result = asyncProfiler.execute(arg);
if (!result.endsWith("\n")) {
result += "\n";
}
return result;
}
@Override
public void process(final CommandProcess process) {
try {
ProfilerAction profilerAction = ProfilerAction.valueOf(action);
if (ProfilerAction.actions.equals(profilerAction)) {
process.appendResult(new ProfilerModel(actions()));
process.end();
return;
}
final AsyncProfiler asyncProfiler = this.profilerInstance();
if (ProfilerAction.execute.equals(profilerAction)) {
if (actionArg == null) {
process.end(1, "actionArg can not be empty.");
return;
}
String result = execute(asyncProfiler, this.actionArg);
appendExecuteResult(process, result);
} else if (ProfilerAction.start.equals(profilerAction)) {
// Track if file parameter was specified during start
boolean autoGeneratedFile = false;
if (this.file != null) {
fileSpecifiedAtStart = this.file;
logger.debug("File specified during profiler start: {}", fileSpecifiedAtStart);
} else if (this.timeout != null) {
// Auto-generate file if timeout is specified but file is not
try {
this.file = outputFile();
logger.debug("Auto-generated file for timeout: {}", this.file);
fileSpecifiedAtStart = this.file;
autoGeneratedFile = true;
} catch (IOException e) {
logger.warn("Failed to auto-generate file for timeout", e);
}
}
if (this.duration == null) {
String executeArgs = executeArgs(ProfilerAction.start);
String result = execute(asyncProfiler, executeArgs);
ProfilerModel profilerModel = createProfilerModel(result);
// Add information about auto-generated file for timeout
if (autoGeneratedFile && this.file != null) {
profilerModel.setOutputFile(this.file);
profilerModel.setExecuteResult(profilerModel.getExecuteResult()
+ "\nAuto-generated output file will be: " + this.file + "\n");
}
process.appendResult(profilerModel);
} else { // 设置延时执行 stop
final String outputFile = outputFile();
String executeArgs = executeArgs(ProfilerAction.start);
String result = execute(asyncProfiler, executeArgs);
ProfilerModel profilerModel = createProfilerModel(result);
profilerModel.setOutputFile(outputFile);
profilerModel.setDuration(duration);
// 延时执行stop
ArthasBootstrap.getInstance().getScheduledExecutorService().schedule(new Runnable() {
@Override
public void run() {
// 在异步线程执行，profiler命令已经结束，不能输出到客户端
try {
logger.info("stopping profiler ...");
ProfilerModel model = processStop(asyncProfiler, ProfilerAction.stop);
logger.info("profiler output file: " + model.getOutputFile());
logger.info("stop profiler successfully.");
} catch (Throwable e) {
logger.error("stop profiler failure", e);
}
}
}, this.duration, TimeUnit.SECONDS);
process.appendResult(profilerModel);
}
} else if (ProfilerAction.stop.equals(profilerAction)) {
ProfilerModel profilerModel = processStop(asyncProfiler, profilerAction);
process.appendResult(profilerModel);
} else if (ProfilerAction.dump.equals(profilerAction)) {
ProfilerModel profilerModel = processStop(asyncProfiler, profilerAction);
process.appendResult(profilerModel);
} else if (ProfilerAction.resume.equals(profilerAction)) {
String executeArgs = executeArgs(ProfilerAction.resume);
String result = execute(asyncProfiler, executeArgs);
appendExecuteResult(process, result);
} else if (ProfilerAction.check.equals(profilerAction)) {
String executeArgs = executeArgs(ProfilerAction.check);
String result = execute(asyncProfiler, executeArgs);
appendExecuteResult(process, result);
} else if (ProfilerAction.version.equals(profilerAction)) {
String result = asyncProfiler.execute("version=full");
appendExecuteResult(process, result);
} else if (ProfilerAction.status.equals(profilerAction)
|| ProfilerAction.meminfo.equals(profilerAction)
|| ProfilerAction.list.equals(profilerAction)) {
String result = asyncProfiler.execute(profilerAction.toString());
appendExecuteResult(process, result);
} else if (ProfilerAction.dumpCollapsed.equals(profilerAction)) {
if (actionArg == null) {
actionArg = "TOTAL";
}
actionArg = actionArg.toUpperCase();
if ("TOTAL".equals(actionArg) || "SAMPLES".equals(actionArg)) {
String result = asyncProfiler.dumpCollapsed(Counter.valueOf(actionArg));
appendExecuteResult(process, result);
} else {
process.end(1, "ERROR: dumpCollapsed argumment should be TOTAL or SAMPLES. ");
return;
}
} else if (ProfilerAction.dumpFlat.equals(profilerAction)) {
int maxMethods = 0;
if (actionArg != null) {
maxMethods = Integer.valueOf(actionArg);
}
String result = asyncProfiler.dumpFlat(maxMethods);
appendExecuteResult(process, result);
} else if (ProfilerAction.dumpTraces.equals(profilerAction)) {
int maxTraces = 0;
if (actionArg != null) {
maxTraces = Integer.valueOf(actionArg);
}
String result = asyncProfiler.dumpTraces(maxTraces);
appendExecuteResult(process, result);
} else if (ProfilerAction.getSamples.equals(profilerAction)) {
String result = "" + asyncProfiler.getSamples() + "\n";
appendExecuteResult(process, result);
}
process.end();
} catch (Throwable e) {
logger.error("AsyncProfiler error", e);
process.end(1, "AsyncProfiler error: "+e.getMessage());
}
}
private ProfilerModel processStop(AsyncProfiler asyncProfiler, ProfilerAction profilerAction) throws IOException {
String outputFile = null;
// If we're stopping and a file was specified during start, don't generate a new
// output file
if (profilerAction == ProfilerAction.stop && fileSpecifiedAtStart != null) {
outputFile = fileSpecifiedAtStart;
// Reset the tracking variable after stop
logger.debug("Using file specified during start: {}", fileSpecifiedAtStart);
fileSpecifiedAtStart = null;
} else {
// Otherwise generate or use the specified output file
outputFile = outputFile();
}
String executeArgs = executeArgs(profilerAction);
String result = execute(asyncProfiler, executeArgs);
ProfilerModel profilerModel = createProfilerModel(result);
if (outputFile != null) {
profilerModel.setOutputFile(outputFile);
}
return profilerModel;
}
private String outputFile() throws IOException {
if (this.file == null) {
String fileExt = outputFileExt();
File outputPath = ArthasBootstrap.getInstance().getOutputPath();
if (outputPath != null) {
this.file = new File(outputPath,
new SimpleDateFormat("yyyyMMdd-HHmmss").format(new Date()) + "." + fileExt)
.getAbsolutePath();
} else {
this.file = File.createTempFile("arthas-output", "." + fileExt).getAbsolutePath();
}
}
return file;
}
/**
* This method should only be called when {@code this.file == null} is true.
*/
private String outputFileExt() {
String fileExt = "";
if (this.format == null) {
fileExt = "html";
} else if (this.format.startsWith("flat") || this.format.startsWith("traces")
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | true |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/ThreadCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/ThreadCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.BlockingLockInfo;
import com.taobao.arthas.core.command.model.BusyThreadInfo;
import com.taobao.arthas.core.command.model.ThreadModel;
import com.taobao.arthas.core.command.model.ThreadVO;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.ExitStatus;
import com.taobao.arthas.core.util.ArrayUtils;
import com.taobao.arthas.core.util.CommandUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.ThreadUtil;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.lang.Thread.State;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author hengyunabc 2015年12月7日 下午2:06:21
*/
@Name("thread")
@Summary("Display thread info, thread stack")
@Description(Constants.EXAMPLE +
" thread\n" +
" thread 51\n" +
" thread -n -1\n" +
" thread -n 5\n" +
" thread -b\n" +
" thread -i 2000\n" +
" thread --state BLOCKED\n" +
Constants.WIKI + Constants.WIKI_HOME + "thread")
public class ThreadCommand extends AnnotatedCommand {
private static Set<String> states = null;
private static ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
private long id = -1;
private Integer topNBusy = null;
private boolean findMostBlockingThread = false;
private int sampleInterval = 200;
private String state;
private boolean lockedMonitors = false;
private boolean lockedSynchronizers = false;
private boolean all = false;
static {
states = new HashSet<String>(State.values().length);
for (State state : State.values()) {
states.add(state.name());
}
}
@Argument(index = 0, required = false, argName = "id")
@Description("Show thread stack")
public void setId(long id) {
this.id = id;
}
@Option(longName = "all", flag = true)
@Description("Display all thread results instead of the first page")
public void setAll(boolean all) {
this.all = all;
}
@Option(shortName = "n", longName = "top-n-threads")
@Description("The number of thread(s) to show, ordered by cpu utilization, -1 to show all.")
public void setTopNBusy(Integer topNBusy) {
this.topNBusy = topNBusy;
}
@Option(shortName = "b", longName = "include-blocking-thread", flag = true)
@Description("Find the thread who is holding a lock that blocks the most number of threads.")
public void setFindMostBlockingThread(boolean findMostBlockingThread) {
this.findMostBlockingThread = findMostBlockingThread;
}
@Option(shortName = "i", longName = "sample-interval")
@Description("Specify the sampling interval (in ms) when calculating cpu usage.")
public void setSampleInterval(int sampleInterval) {
this.sampleInterval = sampleInterval;
}
@Option(longName = "state")
@Description("Display the thread filter by the state. NEW, RUNNABLE, TIMED_WAITING, WAITING, BLOCKED, TERMINATED is optional.")
public void setState(String state) {
this.state = state;
}
@Option(longName = "lockedMonitors", flag = true)
@Description("Find the thread info with lockedMonitors flag, default value is false.")
public void setLockedMonitors(boolean lockedMonitors) {
this.lockedMonitors = lockedMonitors;
}
@Option(longName = "lockedSynchronizers", flag = true)
@Description("Find the thread info with lockedSynchronizers flag, default value is false.")
public void setLockedSynchronizers(boolean lockedSynchronizers) {
this.lockedSynchronizers = lockedSynchronizers;
}
@Override
public void process(CommandProcess process) {
ExitStatus exitStatus;
if (id > 0) {
exitStatus = processThread(process);
} else if (topNBusy != null) {
exitStatus = processTopBusyThreads(process);
} else if (findMostBlockingThread) {
exitStatus = processBlockingThread(process);
} else {
exitStatus = processAllThreads(process);
}
CommandUtils.end(process, exitStatus);
}
private ExitStatus processAllThreads(CommandProcess process) {
List<ThreadVO> threads = ThreadUtil.getThreads();
// 统计各种线程状态
Map<State, Integer> stateCountMap = new LinkedHashMap<State, Integer>();
for (State s : State.values()) {
stateCountMap.put(s, 0);
}
for (ThreadVO thread : threads) {
State threadState = thread.getState();
Integer count = stateCountMap.get(threadState);
stateCountMap.put(threadState, count + 1);
}
boolean includeInternalThreads = true;
Collection<ThreadVO> resultThreads = new ArrayList<ThreadVO>();
if (!StringUtils.isEmpty(this.state)) {
this.state = this.state.toUpperCase();
if (states.contains(this.state)) {
includeInternalThreads = false;
for (ThreadVO thread : threads) {
if (thread.getState() != null && state.equals(thread.getState().name())) {
resultThreads.add(thread);
}
}
} else {
return ExitStatus.failure(1, "Illegal argument, state should be one of " + states);
}
} else {
resultThreads = threads;
}
//thread stats
ThreadSampler threadSampler = new ThreadSampler();
threadSampler.setIncludeInternalThreads(includeInternalThreads);
threadSampler.sample(resultThreads);
threadSampler.pause(sampleInterval);
List<ThreadVO> threadStats = threadSampler.sample(resultThreads);
process.appendResult(new ThreadModel(threadStats, stateCountMap, all));
return ExitStatus.success();
}
private ExitStatus processBlockingThread(CommandProcess process) {
BlockingLockInfo blockingLockInfo = ThreadUtil.findMostBlockingLock();
if (blockingLockInfo.getThreadInfo() == null) {
return ExitStatus.failure(1, "No most blocking thread found!");
}
process.appendResult(new ThreadModel(blockingLockInfo));
return ExitStatus.success();
}
private ExitStatus processTopBusyThreads(CommandProcess process) {
ThreadSampler threadSampler = new ThreadSampler();
threadSampler.sample(ThreadUtil.getThreads());
threadSampler.pause(sampleInterval);
List<ThreadVO> threadStats = threadSampler.sample(ThreadUtil.getThreads());
int limit = Math.min(threadStats.size(), topNBusy);
List<ThreadVO> topNThreads = null;
if (limit > 0) {
topNThreads = threadStats.subList(0, limit);
} else { // -1 for all threads
topNThreads = threadStats;
}
List<Long> tids = new ArrayList<Long>(topNThreads.size());
for (ThreadVO thread : topNThreads) {
if (thread.getId() > 0) {
tids.add(thread.getId());
}
}
ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(ArrayUtils.toPrimitive(tids.toArray(new Long[0])), lockedMonitors, lockedSynchronizers);
if (tids.size()> 0 && threadInfos == null) {
return ExitStatus.failure(1, "get top busy threads failed");
}
//threadInfo with cpuUsage
List<BusyThreadInfo> busyThreadInfos = new ArrayList<BusyThreadInfo>(topNThreads.size());
for (ThreadVO thread : topNThreads) {
ThreadInfo threadInfo = findThreadInfoById(threadInfos, thread.getId());
if (threadInfo != null) {
BusyThreadInfo busyThread = new BusyThreadInfo(thread, threadInfo);
busyThreadInfos.add(busyThread);
}
}
process.appendResult(new ThreadModel(busyThreadInfos));
return ExitStatus.success();
}
private ThreadInfo findThreadInfoById(ThreadInfo[] threadInfos, long id) {
for (int i = 0; i < threadInfos.length; i++) {
ThreadInfo threadInfo = threadInfos[i];
if (threadInfo != null && threadInfo.getThreadId() == id) {
return threadInfo;
}
}
return null;
}
private ExitStatus processThread(CommandProcess process) {
ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(new long[]{id}, lockedMonitors, lockedSynchronizers);
if (threadInfos == null || threadInfos.length < 1 || threadInfos[0] == null) {
return ExitStatus.failure(1, "thread do not exist! id: " + id);
}
process.appendResult(new ThreadModel(threadInfos[0]));
return ExitStatus.success();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/MBeanCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/MBeanCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.MBeanAttributeVO;
import com.taobao.arthas.core.command.model.MBeanModel;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.command.CommandInterruptHandler;
import com.taobao.arthas.core.shell.handlers.shell.QExitHandler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.TokenUtils;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.util.matcher.RegexMatcher;
import com.taobao.arthas.core.util.matcher.WildcardMatcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.TabularData;
/**
* Date: 2019/4/18
*
* @author xuzhiyi
*/
@Name("mbean")
@Summary("Display the mbean information")
@Description("\nExamples:\n" +
" mbean\n" +
" mbean -m java.lang:type=Threading\n" +
" mbean java.lang:type=Threading\n" +
" mbean java.lang:type=Threading *Count\n" +
" mbean java.lang:type=MemoryPool,name=PS\\ Old\\ Gen\n" +
" mbean java.lang:type=MemoryPool,name=*\n" +
" mbean java.lang:type=MemoryPool,name=* Usage\n" +
" mbean -E java.lang:type=Threading PeakThreadCount|ThreadCount|DaemonThreadCount\n" +
" mbean -i 1000 java.lang:type=Threading *Count\n" +
Constants.WIKI + Constants.WIKI_HOME + "mbean")
public class MBeanCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(MBeanCommand.class);
private String name;
private String attribute;
private boolean isRegEx = false;
private long interval = 0;
private boolean metaData;
private int numOfExecutions = 100;
private Timer timer;
private long count = 0;
@Argument(argName = "name-pattern", index = 0, required = false)
@Description("ObjectName pattern, see javax.management.ObjectName for more detail. \n" +
"It looks like this: \n" +
" domain: key-property-list\n" +
"For example: \n" +
" java.lang:name=G1 Old Gen,type=MemoryPool\n" +
" java.lang:name=*,type=MemoryPool")
public void setNamePattern(String name) {
this.name = name;
}
@Argument(argName = "attribute-pattern", index = 1, required = false)
@Description("Attribute name pattern.")
public void setAttributePattern(String attribute) {
this.attribute = attribute;
}
@Option(shortName = "i", longName = "interval")
@Description("The interval (in ms) between two executions.")
public void setInterval(long interval) {
this.interval = interval;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match attribute name (wildcard matching by default).")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "m", longName = "metadata", flag = true)
@Description("Show metadata of mbean.")
public void setMetaData(boolean metaData) {
this.metaData = metaData;
}
@Option(shortName = "n", longName = "number-of-execution")
@Description("The number of times this command will be executed.")
public void setNumOfExecutions(int numOfExecutions) {
this.numOfExecutions = numOfExecutions;
}
public String getName() {
return name;
}
public boolean isRegEx() {
return isRegEx;
}
public boolean isMetaData() {
return metaData;
}
public long getInterval() {
return interval;
}
public int getNumOfExecutions() {
return numOfExecutions;
}
@Override
public void process(CommandProcess process) {
//每个分支调用process.end()结束执行
if (StringUtils.isEmpty(getName())) {
listMBean(process);
} else if (isMetaData()) {
listMetaData(process);
} else {
listAttribute(process);
}
}
private void listMBean(CommandProcess process) {
Set<ObjectName> objectNames = queryObjectNames();
List<String> mbeanNames = new ArrayList<String>(objectNames.size());
for (ObjectName objectName : objectNames) {
mbeanNames.add(objectName.toString());
}
process.appendResult(new MBeanModel(mbeanNames));
process.end();
}
private void listAttribute(final CommandProcess process) {
Session session = process.session();
timer = new Timer("Timer-for-arthas-mbean-" + session.getSessionId(), true);
// ctrl-C support
process.interruptHandler(new MBeanInterruptHandler(process, timer));
// 通过handle回调，在suspend和end时停止timer，resume时重启timer
Handler<Void> stopHandler = new Handler<Void>() {
@Override
public void handle(Void event) {
stop();
}
};
Handler<Void> restartHandler = new Handler<Void>() {
@Override
public void handle(Void event) {
restart(process);
}
};
process.suspendHandler(stopHandler);
process.resumeHandler(restartHandler);
process.endHandler(stopHandler);
// q exit support
process.stdinHandler(new QExitHandler(process));
// start the timer
if (getInterval() > 0) {
timer.scheduleAtFixedRate(new MBeanTimerTask(process), 0, getInterval());
} else {
timer.schedule(new MBeanTimerTask(process), 0);
}
//异步执行，这里不能调用process.end()，在timer task中结束命令执行
}
public synchronized void stop() {
if (timer != null) {
timer.cancel();
timer.purge();
timer = null;
}
}
public synchronized void restart(CommandProcess process) {
if (timer == null) {
Session session = process.session();
timer = new Timer("Timer-for-arthas-mbean-" + session.getSessionId(), true);
timer.scheduleAtFixedRate(new MBeanTimerTask(process), 0, getInterval());
}
}
private void listMetaData(CommandProcess process) {
Set<ObjectName> objectNames = queryObjectNames();
MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
try {
MBeanModel mbeanModel = new MBeanModel();
Map<String, MBeanInfo> mbeanMetaData = new LinkedHashMap<String, MBeanInfo>();
mbeanModel.setMbeanMetadata(mbeanMetaData);
for (ObjectName objectName : objectNames) {
MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName);
mbeanMetaData.put(objectName.toString(), mBeanInfo);
}
process.appendResult(mbeanModel);
process.end();
} catch (Throwable e) {
logger.warn("listMetaData error", e);
process.end(1, "list mbean metadata error");
}
}
@Override
public void complete(Completion completion) {
int argumentIndex = CompletionUtils.detectArgumentIndex(completion);
if (argumentIndex == 1) {
if (!completeBeanName(completion)) {
super.complete(completion);
}
return;
} else if (argumentIndex == 2) {
if (!completeAttributeName(completion)) {
super.complete(completion);
}
return;
}
super.complete(completion);
}
private boolean completeBeanName(Completion completion) {
List<CliToken> tokens = completion.lineTokens();
String lastToken = TokenUtils.getLast(tokens).value();
if (StringUtils.isBlank(lastToken)) {
lastToken = "";
}
if (lastToken.startsWith("-") || lastToken.startsWith("--")) {
return false;
}
Set<ObjectName> objectNames = queryObjectNames();
Set<String> names = new HashSet<String>();
if (objectNames == null) {
return false;
}
for (ObjectName objectName : objectNames) {
String name = objectName.toString();
if (name.startsWith(lastToken)) {
int index = name.indexOf('.', lastToken.length());
if (index > 0) {
names.add(name.substring(0, index + 1));
continue;
}
index = name.indexOf(':', lastToken.length());
if (index > 0) {
names.add(name.substring(0, index + 1));
continue;
}
names.add(name);
}
}
String next = names.iterator().next();
if (names.size() == 1 && (next.endsWith(".") || next.endsWith(":"))) {
completion.complete(next.substring(lastToken.length()), false);
return true;
} else {
return CompletionUtils.complete(completion, names);
}
}
private boolean completeAttributeName(Completion completion) {
List<CliToken> tokens = completion.lineTokens();
String lastToken = TokenUtils.getLast(tokens).value();
if (StringUtils.isBlank(lastToken)) {
lastToken = "";
}
MBeanServer platformMBeanServer = ManagementFactory.getPlatformMBeanServer();
String beanName = TokenUtils.retrievePreviousArg(tokens, lastToken);
Set<ObjectName> objectNames = null;
try {
objectNames = platformMBeanServer.queryNames(new ObjectName(beanName), null);
} catch (MalformedObjectNameException e) {
logger.warn("queryNames error", e);
}
if (objectNames == null || objectNames.size() == 0) {
return false;
}
try {
MBeanInfo mBeanInfo = platformMBeanServer.getMBeanInfo(objectNames.iterator().next());
List<String> attributeNames = new ArrayList<String>();
MBeanAttributeInfo[] attributes = mBeanInfo.getAttributes();
for (MBeanAttributeInfo attribute : attributes) {
if (StringUtils.isBlank(lastToken)) {
attributeNames.add(attribute.getName());
} else if (attribute.getName().startsWith(lastToken)) {
attributeNames.add(attribute.getName());
}
}
return CompletionUtils.complete(completion, attributeNames);
} catch (Throwable e) {
logger.warn("getMBeanInfo error", e);
}
return false;
}
private Set<ObjectName> queryObjectNames() {
MBeanServer platformMBeanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> objectNames = new HashSet<ObjectName>();
try {
if (StringUtils.isEmpty(name)) {
name = "*:*";
}
objectNames = platformMBeanServer.queryNames(new ObjectName(name), null);
} catch (MalformedObjectNameException e) {
logger.warn("queryObjectNames error", e);
}
return objectNames;
}
private Matcher<String> getAttributeMatcher() {
if (StringUtils.isEmpty(attribute)) {
attribute = isRegEx ? ".*" : "*";
}
return isRegEx ? new RegexMatcher(attribute) : new WildcardMatcher(attribute);
}
public static class MBeanInterruptHandler extends CommandInterruptHandler {
private volatile Timer timer;
public MBeanInterruptHandler(CommandProcess process, Timer timer) {
super(process);
this.timer = timer;
}
@Override
public void handle(Void event) {
timer.cancel();
super.handle(event);
}
}
private class MBeanTimerTask extends TimerTask {
private CommandProcess process;
public MBeanTimerTask(CommandProcess process) {
this.process = process;
}
@Override
public void run() {
if (count >= getNumOfExecutions()) {
// stop the timer
timer.cancel();
timer.purge();
process.end(-1, "Process ends after " + getNumOfExecutions() + " time(s).");
return;
}
try {
//result model
MBeanModel mBeanModel = new MBeanModel();
Map<String, List<MBeanAttributeVO>> mbeanAttributeMap = new LinkedHashMap<String, List<MBeanAttributeVO>>();
mBeanModel.setMbeanAttribute(mbeanAttributeMap);
MBeanServer platformMBeanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> objectNames = queryObjectNames();
for (ObjectName objectName : objectNames) {
List<MBeanAttributeVO> attributeVOs = null;
MBeanInfo mBeanInfo = platformMBeanServer.getMBeanInfo(objectName);
MBeanAttributeInfo[] attributes = mBeanInfo.getAttributes();
for (MBeanAttributeInfo attribute : attributes) {
String attributeName = attribute.getName();
if (!getAttributeMatcher().matching(attributeName)) {
continue;
}
//create attributeVO list
if (attributeVOs == null) {
attributeVOs = new ArrayList<MBeanAttributeVO>();
mbeanAttributeMap.put(objectName.toString(), attributeVOs);
}
if (!attribute.isReadable()) {
attributeVOs.add(new MBeanAttributeVO(attributeName, null, "Unavailable"));
} else {
try {
Object attributeObj = platformMBeanServer.getAttribute(objectName, attributeName);
attributeVOs.add(createMBeanAttributeVO(attributeName, attributeObj));
} catch (Throwable e) {
logger.error("read mbean attribute failed: objectName={}, attributeName={}", objectName, attributeName, e);
String errorStr;
Throwable cause = e.getCause();
if (cause instanceof UnsupportedOperationException) {
errorStr = "Unsupported";
} else {
errorStr = "Failure";
}
attributeVOs.add(new MBeanAttributeVO(attributeName, null, errorStr));
}
}
}
}
process.appendResult(mBeanModel);
} catch (Throwable e) {
logger.warn("read mbean error", e);
stop();
process.end(1, "read mbean error.");
return;
}
count++;
process.times().incrementAndGet();
if (getInterval() <= 0) {
stop();
process.end();
}
}
}
private MBeanAttributeVO createMBeanAttributeVO(String attributeName, Object originAttrValue) {
Object attrValue = convertAttrValue(attributeName, originAttrValue);
return new MBeanAttributeVO(attributeName, attrValue);
}
private Object convertAttrValue(String attributeName, Object originAttrValue) {
Object attrValue = originAttrValue;
try {
if (originAttrValue instanceof ObjectName) {
attrValue = String.valueOf(originAttrValue);
} else if (attrValue instanceof CompositeData) {
//mbean java.lang:type=MemoryPool,name=*
CompositeData compositeData = (CompositeData) attrValue;
attrValue = convertCompositeData(attributeName, compositeData);
} else if (attrValue instanceof CompositeData[]) {
//mbean com.sun.management:type=HotSpotDiagnostic
CompositeData[] compositeDataArray = (CompositeData[]) attrValue;
List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>(compositeDataArray.length);
for (CompositeData compositeData : compositeDataArray) {
dataList.add(convertCompositeData(attributeName, compositeData));
}
attrValue = dataList;
} else if (attrValue instanceof TabularData) {
//mbean java.lang:type=GarbageCollector,name=*
TabularData tabularData = (TabularData) attrValue;
Collection<CompositeData> compositeDataList = (Collection<CompositeData>) tabularData.values();
List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>(compositeDataList.size());
for (CompositeData compositeData : compositeDataList) {
dataList.add(convertCompositeData(attributeName, compositeData));
}
attrValue = dataList;
}
} catch (Throwable e) {
logger.error("convert mbean attribute error, attribute: {}={}", attributeName, originAttrValue, e);
attrValue = String.valueOf(originAttrValue);
}
return attrValue;
}
private Map<String, Object> convertCompositeData(String attributeName, CompositeData compositeData) {
Set<String> keySet = compositeData.getCompositeType().keySet();
String[] keys = keySet.toArray(new String[0]);
Object[] values = compositeData.getAll(keys);
Map<String, Object> data = new LinkedHashMap<String, Object>();
for (int i = 0; i < keys.length; i++) {
data.put(keys[i], convertAttrValue(attributeName + "." + keys[i], values[i]));
}
return data;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/EnhancerCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/EnhancerCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.lang.instrument.Instrumentation;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.AdviceWeaver;
import com.taobao.arthas.core.advisor.Enhancer;
import com.taobao.arthas.core.advisor.InvokeTraceable;
import com.taobao.arthas.core.command.model.EnhancerModel;
import com.taobao.arthas.core.command.model.EnhancerModelFactory;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.command.CommandInterruptHandler;
import com.taobao.arthas.core.shell.handlers.shell.QExitHandler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.view.Ansi;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Option;
/**
* @author beiwei30 on 29/11/2016.
*/
public abstract class EnhancerCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(EnhancerCommand.class);
protected static final List<String> EMPTY = Collections.emptyList();
public static final String[] EXPRESS_EXAMPLES = { "params", "returnObj", "throwExp", "target", "clazz", "method",
"{params,returnObj}", "params[0]" };
private String excludeClassPattern;
protected Matcher classNameMatcher;
protected Matcher classNameExcludeMatcher;
protected Matcher methodNameMatcher;
protected long listenerId;
protected boolean verbose;
protected int maxNumOfMatchedClass;
protected Long timeout;
protected boolean lazy = false;
@Option(longName = "exclude-class-pattern")
@Description("exclude class name pattern, use either '.' or '/' as separator")
public void setExcludeClassPattern(String excludeClassPattern) {
this.excludeClassPattern = excludeClassPattern;
}
@Option(longName = "listenerId")
@Description("The special listenerId")
public void setListenerId(long listenerId) {
this.listenerId = listenerId;
}
@Option(shortName = "v", longName = "verbose", flag = true)
@Description("Enables print verbose information, default value false.")
public void setVerbosee(boolean verbose) {
this.verbose = verbose;
}
@Option(shortName = "m", longName = "maxMatch")
@DefaultValue("50")
@Description("The maximum of matched class.")
public void setMaxNumOfMatchedClass(int maxNumOfMatchedClass) {
this.maxNumOfMatchedClass = maxNumOfMatchedClass;
}
@Option(longName = "timeout")
@Description("Timeout value in seconds for the command to exit automatically.")
public void setTimeout(Long timeout) {
this.timeout = timeout;
}
public Long getTimeout() {
return timeout;
}
@Option(shortName = "L", longName = "lazy", flag = true)
@Description("Enable lazy mode to enhance classes when they are loaded. Useful when the class is not loaded yet.")
public void setLazy(boolean lazy) {
this.lazy = lazy;
}
public boolean isLazy() {
return lazy;
}
/**
* 类名匹配
*
* @return 获取类名匹配
*/
protected abstract Matcher getClassNameMatcher();
/**
* 排除类名匹配
*/
protected abstract Matcher getClassNameExcludeMatcher();
/**
* 方法名匹配
*
* @return 获取方法名匹配
*/
protected abstract Matcher getMethodNameMatcher();
/**
* 获取监听器
*
* @return 返回监听器
*/
protected abstract AdviceListener getAdviceListener(CommandProcess process);
AdviceListener getAdviceListenerWithId(CommandProcess process) {
if (listenerId != 0) {
AdviceListener listener = AdviceWeaver.listener(listenerId);
if (listener != null) {
return listener;
}
}
return getAdviceListener(process);
}
@Override
public void process(final CommandProcess process) {
// ctrl-C support
process.interruptHandler(new CommandInterruptHandler(process));
// q exit support
process.stdinHandler(new QExitHandler(process));
// start to enhance
enhance(process);
}
@Override
public void complete(Completion completion) {
int argumentIndex = CompletionUtils.detectArgumentIndex(completion);
if (argumentIndex == 1) { // class name
if (!CompletionUtils.completeClassName(completion)) {
super.complete(completion);
}
return;
} else if (argumentIndex == 2) { // method name
if (!CompletionUtils.completeMethodName(completion)) {
super.complete(completion);
}
return;
} else if (argumentIndex == 3) { // watch express
completeArgument3(completion);
return;
}
super.complete(completion);
}
protected void enhance(CommandProcess process) {
Session session = process.session();
if (!session.tryLock()) {
String msg = "someone else is enhancing classes, pls. wait.";
process.appendResult(EnhancerModelFactory.create(null, false, msg));
process.end(-1, msg);
return;
}
EnhancerAffect effect = null;
int lock = session.getLock();
try {
Instrumentation inst = session.getInstrumentation();
AdviceListener listener = getAdviceListenerWithId(process);
if (listener == null) {
logger.error("advice listener is null");
String msg = "advice listener is null, check arthas log";
process.appendResult(EnhancerModelFactory.create(effect, false, msg));
process.end(-1, msg);
return;
}
boolean skipJDKTrace = false;
if(listener instanceof AbstractTraceAdviceListener) {
skipJDKTrace = ((AbstractTraceAdviceListener) listener).getCommand().isSkipJDKTrace();
}
Enhancer enhancer = new Enhancer(listener, listener instanceof InvokeTraceable, skipJDKTrace, getClassNameMatcher(), getClassNameExcludeMatcher(), getMethodNameMatcher(), this.lazy);
// 注册通知监听器
process.register(listener, enhancer);
effect = enhancer.enhance(inst, this.maxNumOfMatchedClass);
if (effect.getThrowable() != null) {
String msg = "error happens when enhancing class: "+effect.getThrowable().getMessage();
process.appendResult(EnhancerModelFactory.create(effect, false, msg));
process.end(1, msg + ", check arthas log: " + LogUtil.loggingFile());
return;
}
if (effect.cCnt() == 0 || effect.mCnt() == 0) {
// no class effected
if (!StringUtils.isEmpty(effect.getOverLimitMsg())) {
process.appendResult(EnhancerModelFactory.create(effect, false));
process.end(-1);
return;
}
// 懒加载模式：即使没有匹配的类也不立即结束，等待类加载
if (this.lazy) {
String lazyMsg = "Lazy mode is enabled, waiting for class to be loaded. Press Q or Ctrl+C to abort.\n"
+ "When the target class is loaded, it will be automatically enhanced.";
process.write(lazyMsg + "\n");
} else {
// might be method code too large
process.appendResult(EnhancerModelFactory.create(effect, false, "No class or method is affected"));
String smCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("sm CLASS_NAME METHOD_NAME").reset().toString();
String optionsCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("options unsafe true").reset().toString();
String javaPackage = Ansi.ansi().fg(Ansi.Color.GREEN).a("java.*").reset().toString();
String resetCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("reset CLASS_NAME").reset().toString();
String logStr = Ansi.ansi().fg(Ansi.Color.GREEN).a(LogUtil.loggingFile()).reset().toString();
String issueStr = Ansi.ansi().fg(Ansi.Color.GREEN).a("https://github.com/alibaba/arthas/issues/47").reset().toString();
String msg = "No class or method is affected, try:\n"
+ "1. Execute `" + smCommand + "` to make sure the method you are tracing actually exists (it might be in your parent class).\n"
+ "2. Execute `" + optionsCommand + "`, if you want to enhance the classes under the `" + javaPackage + "` package.\n"
+ "3. Execute `" + resetCommand + "` and try again, your method body might be too large.\n"
+ "4. Match the constructor, use `<init>`, for example: `watch demo.MathGame <init>`\n"
+ "5. Check arthas log: " + logStr + "\n"
+ "6. Visit " + issueStr + " for more details.\n"
+ "7. If the class is not loaded yet, try to use `--lazy` or `-L` option to enable lazy mode.";
process.end(-1, msg);
return;
}
}
// 这里做个补偿,如果在enhance期间,unLock被调用了,则补偿性放弃
if (session.getLock() == lock) {
if (process.isForeground()) {
process.echoTips(Constants.Q_OR_CTRL_C_ABORT_MSG + "\n");
}
}
process.appendResult(EnhancerModelFactory.create(effect, true));
// 设置超时任务
scheduleTimeoutTask(process);
//异步执行，在AdviceListener中结束
} catch (Throwable e) {
String msg = "error happens when enhancing class: "+e.getMessage();
logger.error(msg, e);
process.appendResult(EnhancerModelFactory.create(effect, false, msg));
process.end(-1, msg);
} finally {
if (session.getLock() == lock) {
// enhance结束后解锁
process.session().unLock();
}
}
}
protected void completeArgument3(Completion completion) {
super.complete(completion);
}
public String getExcludeClassPattern() {
return excludeClassPattern;
}
/**
* Schedule a timeout task to end the command after the specified timeout.
*
* @param process the command process
*/
private void scheduleTimeoutTask(final CommandProcess process) {
if (timeout == null || timeout <= 0) {
return;
}
final ScheduledFuture<?> timeoutFuture = ArthasBootstrap.getInstance().getScheduledExecutorService()
.schedule(new Runnable() {
@Override
public void run() {
if (process.isRunning()) {
process.write("Command execution timeout after " + timeout + " seconds.\n");
process.end();
}
}
}, timeout, TimeUnit.SECONDS);
// Cancel the timeout task if the process ends normally
process.endHandler(new com.taobao.arthas.core.shell.handlers.Handler<Void>() {
@Override
public void handle(Void event) {
timeoutFuture.cancel(false);
}
});
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/JvmCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/JvmCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.JvmModel;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Summary;
import java.lang.management.*;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* JVM info command
*
* @author vlinux on 15/6/6.
*/
@Name("jvm")
@Summary("Display the target JVM information")
@Description(Constants.WIKI + Constants.WIKI_HOME + "jvm")
public class JvmCommand extends AnnotatedCommand {
private final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
private final ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
private final CompilationMXBean compilationMXBean = ManagementFactory.getCompilationMXBean();
private final Collection<GarbageCollectorMXBean> garbageCollectorMXBeans = ManagementFactory.getGarbageCollectorMXBeans();
private final Collection<MemoryManagerMXBean> memoryManagerMXBeans = ManagementFactory.getMemoryManagerMXBeans();
private final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
// private final Collection<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
private final OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
private final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
@Override
public void process(CommandProcess process) {
JvmModel jvmModel = new JvmModel();
addRuntimeInfo(jvmModel);
addClassLoading(jvmModel);
addCompilation(jvmModel);
if (!garbageCollectorMXBeans.isEmpty()) {
addGarbageCollectors(jvmModel);
}
if (!memoryManagerMXBeans.isEmpty()) {
addMemoryManagers(jvmModel);
}
addMemory(jvmModel);
addOperatingSystem(jvmModel);
addThread(jvmModel);
addFileDescriptor(jvmModel);
process.appendResult(jvmModel);
process.end();
}
private void addFileDescriptor(JvmModel jvmModel) {
String group = "FILE-DESCRIPTOR";
jvmModel.addItem(group,"MAX-FILE-DESCRIPTOR-COUNT", invokeFileDescriptor(operatingSystemMXBean, "getMaxFileDescriptorCount"))
.addItem(group,"OPEN-FILE-DESCRIPTOR-COUNT", invokeFileDescriptor(operatingSystemMXBean, "getOpenFileDescriptorCount"));
}
private long invokeFileDescriptor(OperatingSystemMXBean os, String name) {
try {
final Method method = os.getClass().getDeclaredMethod(name);
method.setAccessible(true);
return (Long) method.invoke(os);
} catch (Exception e) {
return -1;
}
}
private void addRuntimeInfo(JvmModel jvmModel) {
String bootClassPath = "";
try {
bootClassPath = runtimeMXBean.getBootClassPath();
} catch (Exception e) {
// under jdk9 will throw UnsupportedOperationException, ignore
}
String group = "RUNTIME";
jvmModel.addItem(group,"MACHINE-NAME", runtimeMXBean.getName());
jvmModel.addItem(group, "JVM-START-TIME", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(runtimeMXBean.getStartTime())));
jvmModel.addItem(group, "MANAGEMENT-SPEC-VERSION", runtimeMXBean.getManagementSpecVersion());
jvmModel.addItem(group, "SPEC-NAME", runtimeMXBean.getSpecName());
jvmModel.addItem(group, "SPEC-VENDOR", runtimeMXBean.getSpecVendor());
jvmModel.addItem(group, "SPEC-VERSION", runtimeMXBean.getSpecVersion());
jvmModel.addItem(group, "VM-NAME", runtimeMXBean.getVmName());
jvmModel.addItem(group, "VM-VENDOR", runtimeMXBean.getVmVendor());
jvmModel.addItem(group, "VM-VERSION", runtimeMXBean.getVmVersion());
jvmModel.addItem(group, "INPUT-ARGUMENTS", runtimeMXBean.getInputArguments());
jvmModel.addItem(group, "CLASS-PATH", runtimeMXBean.getClassPath());
jvmModel.addItem(group, "BOOT-CLASS-PATH", bootClassPath);
jvmModel.addItem(group, "LIBRARY-PATH", runtimeMXBean.getLibraryPath());
}
private void addClassLoading(JvmModel jvmModel) {
String group = "CLASS-LOADING";
jvmModel.addItem(group, "LOADED-CLASS-COUNT", classLoadingMXBean.getLoadedClassCount());
jvmModel.addItem(group, "TOTAL-LOADED-CLASS-COUNT", classLoadingMXBean.getTotalLoadedClassCount());
jvmModel.addItem(group, "UNLOADED-CLASS-COUNT", classLoadingMXBean.getUnloadedClassCount());
jvmModel.addItem(group, "IS-VERBOSE", classLoadingMXBean.isVerbose());
}
private void addCompilation(JvmModel jvmModel) {
if (compilationMXBean == null) {
return;
}
String group = "COMPILATION";
jvmModel.addItem(group, "NAME", compilationMXBean.getName());
if (compilationMXBean.isCompilationTimeMonitoringSupported()) {
jvmModel.addItem(group, "TOTAL-COMPILE-TIME", compilationMXBean.getTotalCompilationTime(), "time (ms)");
}
}
private void addGarbageCollectors(JvmModel jvmModel) {
String group = "GARBAGE-COLLECTORS";
for (GarbageCollectorMXBean gcMXBean : garbageCollectorMXBeans) {
Map<String, Object> gcInfo = new LinkedHashMap<String, Object>();
gcInfo.put("name", gcMXBean.getName());
gcInfo.put("collectionCount", gcMXBean.getCollectionCount());
gcInfo.put("collectionTime", gcMXBean.getCollectionTime());
jvmModel.addItem(group, gcMXBean.getName(), gcInfo, "count/time (ms)");
}
}
private void addMemoryManagers(JvmModel jvmModel) {
String group = "MEMORY-MANAGERS";
for (final MemoryManagerMXBean memoryManagerMXBean : memoryManagerMXBeans) {
if (memoryManagerMXBean.isValid()) {
final String name = memoryManagerMXBean.isValid()
? memoryManagerMXBean.getName()
: memoryManagerMXBean.getName() + "(Invalid)";
jvmModel.addItem(group, name, memoryManagerMXBean.getMemoryPoolNames());
}
}
}
private void addMemory(JvmModel jvmModel) {
String group = "MEMORY";
MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
Map<String, Object> heapMemoryInfo = getMemoryUsageInfo("heap", heapMemoryUsage);
jvmModel.addItem(group, "HEAP-MEMORY-USAGE", heapMemoryInfo, "memory in bytes");
MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
Map<String, Object> nonheapMemoryInfo = getMemoryUsageInfo("nonheap", nonHeapMemoryUsage);
jvmModel.addItem(group,"NO-HEAP-MEMORY-USAGE", nonheapMemoryInfo, "memory in bytes");
jvmModel.addItem(group,"PENDING-FINALIZE-COUNT", memoryMXBean.getObjectPendingFinalizationCount());
}
private Map<String, Object> getMemoryUsageInfo(String name, MemoryUsage heapMemoryUsage) {
Map<String, Object> memoryInfo = new LinkedHashMap<String, Object>();
memoryInfo.put("name", name);
memoryInfo.put("init", heapMemoryUsage.getInit());
memoryInfo.put("used", heapMemoryUsage.getUsed());
memoryInfo.put("committed", heapMemoryUsage.getCommitted());
memoryInfo.put("max", heapMemoryUsage.getMax());
return memoryInfo;
}
private void addOperatingSystem(JvmModel jvmModel) {
String group = "OPERATING-SYSTEM";
jvmModel.addItem(group,"OS", operatingSystemMXBean.getName())
.addItem(group,"ARCH", operatingSystemMXBean.getArch())
.addItem(group,"PROCESSORS-COUNT", operatingSystemMXBean.getAvailableProcessors())
.addItem(group,"LOAD-AVERAGE", operatingSystemMXBean.getSystemLoadAverage())
.addItem(group,"VERSION", operatingSystemMXBean.getVersion());
}
private void addThread(JvmModel jvmModel) {
String group = "THREAD";
jvmModel.addItem(group, "COUNT", threadMXBean.getThreadCount())
.addItem(group, "DAEMON-COUNT", threadMXBean.getDaemonThreadCount())
.addItem(group, "PEAK-COUNT", threadMXBean.getPeakThreadCount())
.addItem(group, "STARTED-COUNT", threadMXBean.getTotalStartedThreadCount())
.addItem(group, "DEADLOCK-COUNT",getDeadlockedThreadsCount(threadMXBean));
}
private int getDeadlockedThreadsCount(ThreadMXBean threads) {
final long[] ids = threads.findDeadlockedThreads();
if (ids == null) {
return 0;
} else {
return ids.length;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/PerfCounterCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/PerfCounterCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.JavaVersionUtils;
import com.taobao.arthas.common.PidUtils;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.command.model.PerfCounterModel;
import com.taobao.arthas.core.command.model.PerfCounterVO;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import sun.management.counter.Counter;
import sun.management.counter.perf.PerfInstrumentation;
/**
* @see sun.misc.Perf
* @see jdk.internal.perf.Perf
* @see sun.management.counter.perf.PerfInstrumentation
* @author hengyunabc 2020-02-16
*/
@Name("perfcounter")
@Summary("Display the perf counter information.")
@Description("\nExamples:\n" +
" perfcounter\n" +
" perfcounter -d\n" +
Constants.WIKI + Constants.WIKI_HOME + "perfcounter")
public class PerfCounterCommand extends AnnotatedCommand {
private static final Logger logger = LoggerFactory.getLogger(PerfCounterCommand.class);
private static Object perfObject;
private static Method attachMethod;
private boolean details;
@Option(shortName = "d", longName = "details", flag = true)
@Description("print all perf counter details")
public void setDetails(boolean details) {
this.details = details;
}
@Override
public void process(CommandProcess process) {
List<Counter> perfCounters = getPerfCounters();
if (perfCounters.isEmpty()) {
process.end(1,
"please check arthas log. if java version >=9 , try to add jvm options when start your process: "
+ "--add-opens java.base/jdk.internal.perf=ALL-UNNAMED "
+ "--add-exports java.base/jdk.internal.perf=ALL-UNNAMED "
+ "--add-opens java.management/sun.management.counter.perf=ALL-UNNAMED "
+ "--add-opens java.management/sun.management.counter=ALL-UNNAMED");
return;
}
List<PerfCounterVO> perfCounterVOs = new ArrayList<PerfCounterVO>();
for (Counter counter : perfCounters) {
PerfCounterVO perfCounterVO = new PerfCounterVO(counter.getName(), counter.getValue());
if (details) {
perfCounterVO.setUnits(counter.getUnits().toString());
perfCounterVO.setVariability(counter.getVariability().toString());
}
perfCounterVOs.add(perfCounterVO);
}
process.appendResult(new PerfCounterModel(perfCounterVOs, details));
process.end();
}
private static List<Counter> getPerfCounters() {
/**
* <pre>
* Perf p = Perf.getPerf();
* ByteBuffer buffer = p.attach(pid, "r");
* </pre>
*/
try {
if (perfObject == null) {
// jdk8
String perfClassName = "sun.misc.Perf";
// jdk 11
if (!JavaVersionUtils.isLessThanJava9()) {
perfClassName = "jdk.internal.perf.Perf";
}
Class<?> perfClass = ClassLoader.getSystemClassLoader().loadClass(perfClassName);
Method getPerfMethod = perfClass.getDeclaredMethod("getPerf");
perfObject = getPerfMethod.invoke(null);
}
if (attachMethod == null) {
attachMethod = perfObject.getClass().getDeclaredMethod("attach",
new Class<?>[] { int.class, String.class });
}
ByteBuffer buffer = (ByteBuffer) attachMethod.invoke(perfObject,
new Object[] { (int) PidUtils.currentLongPid(), "r" });
PerfInstrumentation perfInstrumentation = new PerfInstrumentation(buffer);
return perfInstrumentation.getAllCounters();
} catch (Throwable e) {
logger.error("get perf counter error", e);
}
return Collections.emptyList();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorData.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/MonitorData.java | package com.taobao.arthas.core.command.monitor200;
import java.time.LocalDateTime;
/**
* 数据监控用的value for MonitorCommand
*
* @author vlinux
*/
public class MonitorData {
private String className;
private String methodName;
private int total;
private int success;
private int failed;
private double cost;
private LocalDateTime timestamp;
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public int getSuccess() {
return success;
}
public void setSuccess(int success) {
this.success = success;
}
public int getFailed() {
return failed;
}
public void setFailed(int failed) {
this.failed = failed;
}
public double getCost() {
return cost;
}
public void setCost(double cost) {
this.cost = cost;
}
public LocalDateTime getTimestamp() {
if (timestamp == null) {
timestamp = LocalDateTime.now();
}
return timestamp;
}
public void setTimestamp(LocalDateTime timestamp) {
this.timestamp = timestamp;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/ThreadSampler.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/ThreadSampler.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.command.model.ThreadVO;
import sun.management.HotspotThreadMBean;
import sun.management.ManagementFactoryHelper;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Thread cpu sampler
*
* @author gongdewei 2020/4/23
*/
public class ThreadSampler {
private static ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
private static HotspotThreadMBean hotspotThreadMBean;
private static boolean hotspotThreadMBeanEnable = true;
private Map<ThreadVO, Long> lastCpuTimes = new HashMap<ThreadVO, Long>();
private long lastSampleTimeNanos;
private boolean includeInternalThreads = true;
public List<ThreadVO> sample(Collection<ThreadVO> originThreads) {
List<ThreadVO> threads = new ArrayList<ThreadVO>(originThreads);
// Sample CPU
if (lastCpuTimes.isEmpty()) {
lastSampleTimeNanos = System.nanoTime();
for (ThreadVO thread : threads) {
if (thread.getId() > 0) {
long cpu = threadMXBean.getThreadCpuTime(thread.getId());
lastCpuTimes.put(thread, cpu);
thread.setTime(cpu / 1000000);
}
}
// add internal threads
Map<String, Long> internalThreadCpuTimes = getInternalThreadCpuTimes();
if (internalThreadCpuTimes != null) {
for (Map.Entry<String, Long> entry : internalThreadCpuTimes.entrySet()) {
String key = entry.getKey();
ThreadVO thread = createThreadVO(key);
thread.setTime(entry.getValue() / 1000000);
threads.add(thread);
lastCpuTimes.put(thread, entry.getValue());
}
}
//sort by time
Collections.sort(threads, new Comparator<ThreadVO>() {
@Override
public int compare(ThreadVO o1, ThreadVO o2) {
long l1 = o1.getTime();
long l2 = o2.getTime();
if (l1 < l2) {
return 1;
} else if (l1 > l2) {
return -1;
} else {
return 0;
}
}
});
return threads;
}
// Resample
long newSampleTimeNanos = System.nanoTime();
Map<ThreadVO, Long> newCpuTimes = new HashMap<ThreadVO, Long>(threads.size());
for (ThreadVO thread : threads) {
if (thread.getId() > 0) {
long cpu = threadMXBean.getThreadCpuTime(thread.getId());
newCpuTimes.put(thread, cpu);
}
}
// internal threads
Map<String, Long> newInternalThreadCpuTimes = getInternalThreadCpuTimes();
if (newInternalThreadCpuTimes != null) {
for (Map.Entry<String, Long> entry : newInternalThreadCpuTimes.entrySet()) {
ThreadVO threadVO = createThreadVO(entry.getKey());
threads.add(threadVO);
newCpuTimes.put(threadVO, entry.getValue());
}
}
// Compute delta time
final Map<ThreadVO, Long> deltas = new HashMap<ThreadVO, Long>(threads.size());
for (ThreadVO thread : newCpuTimes.keySet()) {
Long t = lastCpuTimes.get(thread);
if (t == null) {
t = 0L;
}
long time1 = t;
long time2 = newCpuTimes.get(thread);
if (time1 == -1) {
time1 = time2;
} else if (time2 == -1) {
time2 = time1;
}
long delta = time2 - time1;
deltas.put(thread, delta);
}
long sampleIntervalNanos = newSampleTimeNanos - lastSampleTimeNanos;
// Compute cpu usage
final HashMap<ThreadVO, Double> cpuUsages = new HashMap<ThreadVO, Double>(threads.size());
for (ThreadVO thread : threads) {
double cpu = sampleIntervalNanos == 0 ? 0 : (Math.rint(deltas.get(thread) * 10000.0 / sampleIntervalNanos) / 100.0);
cpuUsages.put(thread, cpu);
}
// Sort by CPU time : should be a rendering hint...
Collections.sort(threads, new Comparator<ThreadVO>() {
@Override
public int compare(ThreadVO o1, ThreadVO o2) {
long l1 = deltas.get(o1);
long l2 = deltas.get(o2);
if (l1 < l2) {
return 1;
} else if (l1 > l2) {
return -1;
} else {
return 0;
}
}
});
for (ThreadVO thread : threads) {
//nanos to mills
long timeMills = newCpuTimes.get(thread) / 1000000;
long deltaTime = deltas.get(thread) / 1000000;
double cpu = cpuUsages.get(thread);
thread.setCpu(cpu);
thread.setTime(timeMills);
thread.setDeltaTime(deltaTime);
}
lastCpuTimes = newCpuTimes;
lastSampleTimeNanos = newSampleTimeNanos;
return threads;
}
private Map<String, Long> getInternalThreadCpuTimes() {
if (hotspotThreadMBeanEnable && includeInternalThreads) {
try {
if (hotspotThreadMBean == null) {
hotspotThreadMBean = ManagementFactoryHelper.getHotspotThreadMBean();
}
return hotspotThreadMBean.getInternalThreadCpuTimes();
} catch (Throwable e) {
//ignore ex
hotspotThreadMBeanEnable = false;
}
}
return null;
}
private ThreadVO createThreadVO(String name) {
ThreadVO threadVO = new ThreadVO();
threadVO.setId(-1);
threadVO.setName(name);
threadVO.setPriority(-1);
threadVO.setDaemon(true);
threadVO.setInterrupted(false);
return threadVO;
}
public void pause(long mills) {
try {
Thread.sleep(mills);
} catch (InterruptedException e) {
// ignore
}
}
public boolean isIncludeInternalThreads() {
return includeInternalThreads;
}
public void setIncludeInternalThreads(boolean includeInternalThreads) {
this.includeInternalThreads = includeInternalThreads;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/WatchCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/WatchCommand.java | package com.taobao.arthas.core.command.monitor200;
import java.util.Arrays;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.view.ObjectView;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
@Name("watch")
@Summary("Display the input/output parameter, return object, and thrown exception of specified method invocation")
@Description(Constants.EXPRESS_DESCRIPTION + "\nExamples:\n" +
" watch org.apache.commons.lang.StringUtils isBlank\n" +
" watch org.apache.commons.lang.StringUtils isBlank '{params, target, returnObj, throwExp}' -x 2\n" +
" watch *StringUtils isBlank params[0] params[0].length==1\n" +
" watch *StringUtils isBlank params '#cost>100'\n" +
" watch -f *StringUtils isBlank params\n" +
" watch *StringUtils isBlank params[0]\n" +
" watch -E -b org\\.apache\\.commons\\.lang\\.StringUtils isBlank params[0]\n" +
" watch javax.servlet.Filter * --exclude-class-pattern com.demo.TestFilter\n" +
" watch OuterClass$InnerClass\n" +
Constants.WIKI + Constants.WIKI_HOME + "watch")
public class WatchCommand extends EnhancerCommand {
private String classPattern;
private String methodPattern;
private String express;
private String conditionExpress;
private boolean isBefore = false;
private boolean isFinish = false;
private boolean isException = false;
private boolean isSuccess = false;
private Integer expand = 1;
private Integer sizeLimit = 10 * 1024 * 1024;
private boolean isRegEx = false;
private int numberOfLimit = 100;
@Argument(index = 0, argName = "class-pattern")
@Description("The full qualified class name you want to watch")
public void setClassPattern(String classPattern) {
this.classPattern = StringUtils.normalizeClassName(classPattern);
}
@Argument(index = 1, argName = "method-pattern")
@Description("The method name you want to watch")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(index = 2, argName = "express", required = false)
@DefaultValue("{params, target, returnObj}")
@Description("The content you want to watch, written by ognl. Default value is '{params, target, returnObj}'\n" + Constants.EXPRESS_EXAMPLES)
public void setExpress(String express) {
this.express = express;
}
@Argument(index = 3, argName = "condition-express", required = false)
@Description(Constants.CONDITION_EXPRESS)
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
@Option(shortName = "b", longName = "before", flag = true)
@Description("Watch before invocation")
public void setBefore(boolean before) {
isBefore = before;
}
@Option(shortName = "f", longName = "finish", flag = true)
@Description("Watch after invocation, enable by default")
public void setFinish(boolean finish) {
isFinish = finish;
}
@Option(shortName = "e", longName = "exception", flag = true)
@Description("Watch after throw exception")
public void setException(boolean exception) {
isException = exception;
}
@Option(shortName = "s", longName = "success", flag = true)
@Description("Watch after successful invocation")
public void setSuccess(boolean success) {
isSuccess = success;
}
@Option(shortName = "M", longName = "sizeLimit")
@Description("Upper size limit in bytes for the result (10 * 1024 * 1024 by default)")
public void setSizeLimit(Integer sizeLimit) {
this.sizeLimit = sizeLimit;
}
@Option(shortName = "x", longName = "expand")
@Description("Expand level of object (1 by default), the max value is " + ObjectView.MAX_DEEP)
public void setExpand(Integer expand) {
this.expand = expand;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "n", longName = "limits")
@Description("Threshold of execution times")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
public String getClassPattern() {
return classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public String getExpress() {
return express;
}
public String getConditionExpress() {
return conditionExpress;
}
public boolean isBefore() {
return isBefore;
}
public boolean isFinish() {
return isFinish;
}
public boolean isException() {
return isException;
}
public boolean isSuccess() {
return isSuccess;
}
public Integer getExpand() {
return expand;
}
public Integer getSizeLimit() {
return sizeLimit;
}
public boolean isRegEx() {
return isRegEx;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
@Override
protected Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
}
return classNameMatcher;
}
@Override
protected Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
@Override
protected Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
return new WatchAdviceListener(this, process, GlobalOptions.verbose || this.verbose);
}
@Override
protected void completeArgument3(Completion completion) {
CompletionUtils.complete(completion, Arrays.asList(EXPRESS_EXAMPLES));
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.model.TimeFragmentVO;
import com.taobao.arthas.core.command.model.TimeTunnelModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import java.time.LocalDateTime;
import java.util.Collections;
/**
* @author beiwei30 on 30/11/2016.
* @author hengyunabc 2020-05-20
*/
public class TimeTunnelAdviceListener extends AdviceListenerAdapter {
private static final Logger logger = LoggerFactory.getLogger(TimeTunnelAdviceListener.class);
/**
* 用 JDK 的 Object[] 做一个固定大小的 ring stack（只存业务对象），避免把 ArthasClassLoader 加载的 ObjectStack 放进
* 业务线程的 ThreadLocalMap 里，导致 stop/detach 后 ArthasClassLoader 无法被 GC 回收。
*
* <pre>
* 约定：
* - store[0] 存储 int[1] 的 pos（0..cap）
* - store[1..cap] 存储 args（Object[]）
* </pre>
*/
private static final int ARGS_STACK_SIZE = 512;
private final ThreadLocal<Object[]> argsRef = ThreadLocal.withInitial(() -> {
Object[] store = new Object[ARGS_STACK_SIZE + 1];
store[0] = new int[1];
return store;
});
private TimeTunnelCommand command;
private CommandProcess process;
// 第一次启动标记
private volatile boolean isFirst = true;
// 方法执行时间戳
private final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
public TimeTunnelAdviceListener(TimeTunnelCommand command, CommandProcess process, boolean verbose) {
this.command = command;
this.process = process;
super.setVerbose(verbose);
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
pushArgs(args);
threadLocalWatch.start();
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
//取出入参时的 args，因为在函数执行过程中 args可能被修改
args = popArgs();
afterFinishing(Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject));
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) {
//取出入参时的 args，因为在函数执行过程中 args可能被修改
args = popArgs();
afterFinishing(Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable));
}
private void pushArgs(Object[] args) {
Object[] store = argsRef.get();
int[] posHolder = (int[]) store[0];
int cap = store.length - 1;
int pos = posHolder[0];
if (pos < cap) {
pos++;
} else {
// if stack is full, reset pos
pos = 1;
}
store[pos] = args;
posHolder[0] = pos;
}
private Object[] popArgs() {
Object[] store = argsRef.get();
int[] posHolder = (int[]) store[0];
int cap = store.length - 1;
int pos = posHolder[0];
if (pos > 0) {
Object[] args = (Object[]) store[pos];
store[pos] = null;
posHolder[0] = pos - 1;
return args;
}
pos = cap;
Object[] args = (Object[]) store[pos];
store[pos] = null;
posHolder[0] = pos - 1;
return args;
}
private void afterFinishing(Advice advice) {
double cost = threadLocalWatch.costInMillis();
TimeFragment timeTunnel = new TimeFragment(advice, LocalDateTime.now(), cost);
boolean match = false;
try {
match = isConditionMet(command.getConditionExpress(), advice, cost);
if (this.isVerbose()) {
process.write("Condition express: " + command.getConditionExpress() + " , result: " + match + "\n");
}
} catch (ExpressException e) {
logger.warn("tt failed.", e);
process.end(-1, "tt failed, condition is: " + command.getConditionExpress() + ", " + e.getMessage()
+ ", visit " + LogUtil.loggingFile() + " for more details.");
}
if (!match) {
return;
}
int index = command.putTimeTunnel(timeTunnel);
TimeFragmentVO timeFragmentVO = TimeTunnelCommand.createTimeFragmentVO(index, timeTunnel, command.getExpand());
TimeTunnelModel timeTunnelModel = new TimeTunnelModel()
.setTimeFragmentList(Collections.singletonList(timeFragmentVO))
.setFirst(isFirst);
process.appendResult(timeTunnelModel);
if (isFirst) {
isFirst = false;
}
process.times().incrementAndGet();
if (isLimitExceeded(command.getNumberOfLimit(), process.times().get())) {
abortProcess(process, command.getNumberOfLimit());
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/StackCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/StackCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
/**
* Jstack命令<br/>
* 负责输出当前方法执行上下文
*
* @author vlinux
* @author hengyunabc 2016-10-31
*/
@Name("stack")
@Summary("Display the stack trace for the specified class and method")
@Description(Constants.EXPRESS_DESCRIPTION + Constants.EXAMPLE +
" stack org.apache.commons.lang.StringUtils isBlank\n" +
" stack *StringUtils isBlank\n" +
" stack *StringUtils isBlank params[0].length==1\n" +
" stack *StringUtils isBlank '#cost>100'\n" +
" stack -E org\\.apache\\.commons\\.lang\\.StringUtils isBlank\n" +
Constants.WIKI + Constants.WIKI_HOME + "stack")
public class StackCommand extends EnhancerCommand {
private String classPattern;
private String methodPattern;
private String conditionExpress;
private boolean isRegEx = false;
private int numberOfLimit = 100;
@Argument(index = 0, argName = "class-pattern")
@Description("Path and classname of Pattern Matching")
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
@Argument(index = 1, argName = "method-pattern", required = false)
@Description("Method of Pattern Matching")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(index = 2, argName = "condition-express", required = false)
@Description(Constants.CONDITION_EXPRESS)
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "n", longName = "limits")
@Description("Threshold of execution times")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
public String getClassPattern() {
return classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public String getConditionExpress() {
return conditionExpress;
}
public boolean isRegEx() {
return isRegEx;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
@Override
protected Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
}
return classNameMatcher;
}
@Override
protected Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
@Override
protected Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
return new StackAdviceListener(this, process, GlobalOptions.verbose || this.verbose);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/PathTraceAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/PathTraceAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.shell.command.CommandProcess;
/**
* @author ralf0131 2017-01-05 13:59.
*/
public class PathTraceAdviceListener extends AbstractTraceAdviceListener {
public PathTraceAdviceListener(TraceCommand command, CommandProcess process) {
super(command, process);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/AbstractTraceAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/AbstractTraceAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author ralf0131 2017-01-06 16:02.
*/
public class AbstractTraceAdviceListener extends AdviceListenerAdapter {
private static final Logger logger = LoggerFactory.getLogger(AbstractTraceAdviceListener.class);
protected final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
protected TraceCommand command;
protected CommandProcess process;
private final AtomicBoolean processAborted = new AtomicBoolean(false);
protected final ThreadLocal<TraceEntity> threadBoundEntity = new ThreadLocal<TraceEntity>();
/**
* Constructor
*/
public AbstractTraceAdviceListener(TraceCommand command, CommandProcess process) {
this.command = command;
this.process = process;
}
protected TraceEntity threadLocalTraceEntity(ClassLoader loader) {
TraceEntity traceEntity = threadBoundEntity.get();
if (traceEntity == null) {
traceEntity = new TraceEntity(loader);
threadBoundEntity.set(traceEntity);
}
return traceEntity;
}
@Override
public void destroy() {
threadBoundEntity.remove();
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
TraceEntity traceEntity = threadLocalTraceEntity(loader);
traceEntity.tree.begin(clazz.getName(), method.getName(), -1, false);
traceEntity.deep++;
// 开始计算本次方法调用耗时
threadLocalWatch.start();
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
threadLocalTraceEntity(loader).tree.end();
final Advice advice = Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject);
finishing(loader, advice);
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) throws Throwable {
int lineNumber = -1;
StackTraceElement[] stackTrace = throwable.getStackTrace();
if (stackTrace.length != 0) {
lineNumber = stackTrace[0].getLineNumber();
}
threadLocalTraceEntity(loader).tree.end(throwable, lineNumber);
final Advice advice = Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable);
finishing(loader, advice);
}
public TraceCommand getCommand() {
return command;
}
private void finishing(ClassLoader loader, Advice advice) {
// 本次调用的耗时
TraceEntity traceEntity = threadLocalTraceEntity(loader);
if (traceEntity.deep >= 1) { // #1817 防止deep为负数
traceEntity.deep--;
}
if (traceEntity.deep == 0) {
double cost = threadLocalWatch.costInMillis();
try {
boolean conditionResult = isConditionMet(command.getConditionExpress(), advice, cost);
if (this.isVerbose()) {
process.write("Condition express: " + command.getConditionExpress() + " , result: " + conditionResult + "\n");
}
if (conditionResult) {
// 满足输出条件
process.times().incrementAndGet();
// TODO: concurrency issues for process.write
process.appendResult(traceEntity.getModel());
// 是否到达数量限制
if (isLimitExceeded(command.getNumberOfLimit(), process.times().get())) {
abortProcess(process, command.getNumberOfLimit());
}
}
} catch (Throwable e) {
logger.warn("trace failed.", e);
process.end(1, "trace failed, condition is: " + command.getConditionExpress() + ", " + e.getMessage()
+ ", visit " + LogUtil.loggingFile() + " for more details.");
} finally {
threadBoundEntity.remove();
}
}
}
@Override
protected void abortProcess(CommandProcess process, int limit) {
// Only proceed if this thread is the first one to set the flag to true
if (processAborted.compareAndSet(false, true)) {
super.abortProcess(process, limit);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelTable.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TimeTunnelTable.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.command.model.TimeFragmentVO;
import com.taobao.arthas.core.util.DateUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.view.ObjectView;
import com.taobao.text.Decoration;
import com.taobao.text.ui.Element;
import com.taobao.text.ui.LabelElement;
import com.taobao.text.ui.TableElement;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import static com.taobao.text.ui.Element.label;
/**
* @author beiwei30 on 30/11/2016.
*/
public class TimeTunnelTable {
// 各列宽度
private static final int[] TABLE_COL_WIDTH = new int[]{
8, // index
20, // timestamp
10, // cost(ms)
8, // isRet
8, // isExp
15, // object address
30, // class
30, // method
};
// 各列名称
private static final String[] TABLE_COL_TITLE = new String[]{
"INDEX",
"TIMESTAMP",
"COST(ms)",
"IS-RET",
"IS-EXP",
"OBJECT",
"CLASS",
"METHOD"
};
static TableElement createTable() {
return new TableElement(TABLE_COL_WIDTH).leftCellPadding(1).rightCellPadding(1);
}
public static TableElement createDefaultTable() {
return new TableElement().leftCellPadding(1).rightCellPadding(1);
}
static TableElement fillTableHeader(TableElement table) {
LabelElement[] headers = new LabelElement[TABLE_COL_TITLE.length];
for (int i = 0; i < TABLE_COL_TITLE.length; ++i) {
headers[i] = label(TABLE_COL_TITLE[i]).style(Decoration.bold.bold());
}
table.row(true, headers);
return table;
}
// 绘制TimeTunnel表格
public static Element drawTimeTunnelTable(List<TimeFragmentVO> timeFragmentList, boolean withHeader){
TableElement table = createTable();
if (withHeader) {
fillTableHeader(table);
}
for (TimeFragmentVO tf : timeFragmentList) {
fillTableRow(table, tf);
}
return table;
}
// 填充表格行
static TableElement fillTableRow(TableElement table, TimeFragmentVO tf) {
return table.row(
"" + tf.getIndex(),
DateUtils.formatDateTime(tf.getTimestamp()),
"" + tf.getCost(),
"" + tf.isReturn(),
"" + tf.isThrow(),
tf.getObject(),
StringUtils.substringAfterLast("." + tf.getClassName(), "."),
tf.getMethodName()
);
}
public static void drawTimeTunnel(TableElement table, TimeFragmentVO tf) {
table.row("INDEX", "" + tf.getIndex())
.row("GMT-CREATE", DateUtils.formatDateTime(tf.getTimestamp()))
.row("COST(ms)", "" + tf.getCost())
.row("OBJECT", tf.getObject())
.row("CLASS", tf.getClassName())
.row("METHOD", tf.getMethodName())
.row("IS-RETURN", "" + tf.isReturn())
.row("IS-EXCEPTION", "" + tf.isThrow());
}
public static void drawThrowException(TableElement table, TimeFragmentVO tf) {
if (tf.isThrow()) {
//noinspection ThrowableResultOfMethodCallIgnored
ObjectVO throwableVO = tf.getThrowExp();
if (throwableVO.needExpand()) {
table.row("THROW-EXCEPTION", new ObjectView(throwableVO).draw());
} else {
StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
try {
((Throwable) throwableVO.getObject()).printStackTrace(printWriter);
table.row("THROW-EXCEPTION", stringWriter.toString());
} finally {
printWriter.close();
}
}
}
}
public static void drawReturnObj(TableElement table, TimeFragmentVO tf, Integer sizeLimit) {
if (tf.isReturn()) {
if (tf.getReturnObj().needExpand()) {
table.row("RETURN-OBJ", new ObjectView(sizeLimit, tf.getReturnObj()).draw());
} else {
table.row("RETURN-OBJ", "" + StringUtils.objectToString(tf.getReturnObj()));
}
}
}
public static void drawParameters(TableElement table, ObjectVO[] params) {
if (params != null) {
int paramIndex = 0;
for (ObjectVO param : params) {
if (param.needExpand()) {
table.row("PARAMETERS[" + paramIndex++ + "]", new ObjectView(param).draw());
} else {
table.row("PARAMETERS[" + paramIndex++ + "]", "" + StringUtils.objectToString(param));
}
}
}
}
public static void drawWatchTableHeader(TableElement table) {
table.row(true, label("INDEX").style(Decoration.bold.bold()), label("SEARCH-RESULT")
.style(Decoration.bold.bold()));
}
public static void drawWatchResults(TableElement table, Map<Integer, ObjectVO> watchResults, Integer sizeLimit) {
for (Map.Entry<Integer, ObjectVO> entry : watchResults.entrySet()) {
ObjectVO objectVO = entry.getValue();
table.row("" + entry.getKey(), "" +
(objectVO.needExpand() ? new ObjectView(sizeLimit, objectVO).draw() : StringUtils.objectToString(objectVO.getObject())));
}
}
public static TableElement drawPlayHeader(String className, String methodName, String objectAddress, int index,
TableElement table) {
return table.row("RE-INDEX", "" + index)
.row("GMT-REPLAY", DateUtils.formatDateTime(LocalDateTime.now()))
.row("OBJECT", objectAddress)
.row("CLASS", className)
.row("METHOD", methodName);
}
public static void drawPlayResult(TableElement table, ObjectVO returnObjVO,
int sizeLimit, double cost) {
// 执行成功:输出成功状态
table.row("IS-RETURN", "" + true);
table.row("IS-EXCEPTION", "" + false);
table.row("COST(ms)", "" + cost);
// 执行成功:输出成功结果
if (returnObjVO.needExpand()) {
table.row("RETURN-OBJ", new ObjectView(sizeLimit, returnObjVO).draw());
} else {
table.row("RETURN-OBJ", "" + StringUtils.objectToString(returnObjVO.getObject()));
}
}
public static void drawPlayException(TableElement table, ObjectVO throwableVO) {
// 执行失败:输出失败状态
table.row("IS-RETURN", "" + false);
table.row("IS-EXCEPTION", "" + true);
// 执行失败:输出失败异常信息
Throwable cause;
Throwable t = (Throwable) throwableVO.getObject();
if (t instanceof InvocationTargetException) {
cause = t.getCause();
} else {
cause = t;
}
if (throwableVO.needExpand()) {
table.row("THROW-EXCEPTION", new ObjectView(cause, throwableVO.expandOrDefault()).draw());
} else {
StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
try {
cause.printStackTrace(printWriter);
table.row("THROW-EXCEPTION", stringWriter.toString());
} finally {
printWriter.close();
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/StackAdviceListener.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/StackAdviceListener.java | package com.taobao.arthas.core.command.monitor200;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.model.StackModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import com.taobao.arthas.core.util.ThreadUtil;
import java.time.LocalDateTime;
/**
* @author beiwei30 on 29/11/2016.
*/
public class StackAdviceListener extends AdviceListenerAdapter {
private static final Logger logger = LoggerFactory.getLogger(StackAdviceListener.class);
private final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
private StackCommand command;
private CommandProcess process;
public StackAdviceListener(StackCommand command, CommandProcess process, boolean verbose) {
this.command = command;
this.process = process;
super.setVerbose(verbose);
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
// 开始计算本次方法调用耗时
threadLocalWatch.start();
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) throws Throwable {
Advice advice = Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable);
finishing(advice);
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
Advice advice = Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject);
finishing(advice);
}
private void finishing(Advice advice) {
// 本次调用的耗时
try {
double cost = threadLocalWatch.costInMillis();
boolean conditionResult = isConditionMet(command.getConditionExpress(), advice, cost);
if (this.isVerbose()) {
process.write("Condition express: " + command.getConditionExpress() + " , result: " + conditionResult + "\n");
}
if (conditionResult) {
// TODO: concurrency issues for process.write
StackModel stackModel = ThreadUtil.getThreadStackModel(advice.getLoader(), Thread.currentThread());
stackModel.setTs(LocalDateTime.now());
process.appendResult(stackModel);
process.times().incrementAndGet();
if (isLimitExceeded(command.getNumberOfLimit(), process.times().get())) {
abortProcess(process, command.getNumberOfLimit());
}
}
} catch (Throwable e) {
logger.warn("stack failed.", e);
process.end(-1, "stack failed, condition is: " + command.getConditionExpress() + ", " + e.getMessage()
+ ", visit " + LogUtil.loggingFile() + " for more details.");
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/DashboardInterruptHandler.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/DashboardInterruptHandler.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.command.CommandInterruptHandler;
import java.util.Timer;
/**
* @author ralf0131 2017-01-09 13:37.
*/
public class DashboardInterruptHandler extends CommandInterruptHandler {
private volatile Timer timer;
public DashboardInterruptHandler(CommandProcess process, Timer timer) {
super(process);
this.timer = timer;
}
@Override
public void handle(Void event) {
timer.cancel();
super.handle(event);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceCommand.java | core/src/main/java/com/taobao/arthas/core/command/monitor200/TraceCommand.java | package com.taobao.arthas.core.command.monitor200;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.Constants;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.matcher.GroupMatcher;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.util.matcher.RegexMatcher;
import com.taobao.arthas.core.util.matcher.TrueMatcher;
import com.taobao.arthas.core.util.matcher.WildcardMatcher;
import com.taobao.middleware.cli.annotations.Argument;
import com.taobao.middleware.cli.annotations.DefaultValue;
import com.taobao.middleware.cli.annotations.Description;
import com.taobao.middleware.cli.annotations.Name;
import com.taobao.middleware.cli.annotations.Option;
import com.taobao.middleware.cli.annotations.Summary;
import java.util.ArrayList;
import java.util.List;
/**
* 调用跟踪命令<br/>
* 负责输出一个类中的所有方法调用路径
*
* @author vlinux on 15/5/27.
*/
// @formatter:off
@Name("trace")
@Summary("Trace the execution time of specified method invocation.")
@Description(value = Constants.EXPRESS_DESCRIPTION + Constants.EXAMPLE +
" trace org.apache.commons.lang.StringUtils isBlank\n" +
" trace *StringUtils isBlank\n" +
" trace *StringUtils isBlank params[0].length==1\n" +
" trace *StringUtils isBlank '#cost>100'\n" +
" trace -E org\\\\.apache\\\\.commons\\\\.lang\\\\.StringUtils isBlank\n" +
" trace -E com.test.ClassA|org.test.ClassB method1|method2|method3\n" +
" trace demo.MathGame run -n 5\n" +
" trace demo.MathGame run --skipJDKMethod false\n" +
" trace javax.servlet.Filter * --exclude-class-pattern com.demo.TestFilter\n" +
" trace OuterClass$InnerClass *\n" +
Constants.WIKI + Constants.WIKI_HOME + "trace")
//@formatter:on
public class TraceCommand extends EnhancerCommand {
private String classPattern;
private String methodPattern;
private String conditionExpress;
private boolean isRegEx = false;
private int numberOfLimit = 100;
private List<String> pathPatterns;
private boolean skipJDKTrace;
@Argument(argName = "class-pattern", index = 0)
@Description("Class name pattern, use either '.' or '/' as separator")
public void setClassPattern(String classPattern) {
this.classPattern = StringUtils.normalizeClassName(classPattern);
}
@Argument(argName = "method-pattern", index = 1)
@Description("Method name pattern")
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
@Argument(argName = "condition-express", index = 2, required = false)
@Description(Constants.CONDITION_EXPRESS)
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
@Option(shortName = "E", longName = "regex", flag = true)
@Description("Enable regular expression to match (wildcard matching by default)")
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
@Option(shortName = "n", longName = "limits")
@Description("Threshold of execution times")
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
@Option(shortName = "p", longName = "path", acceptMultipleValues = true)
@Description("path tracing pattern")
public void setPathPatterns(List<String> pathPatterns) {
this.pathPatterns = pathPatterns;
}
@Option(longName = "skipJDKMethod")
@DefaultValue("true")
@Description("skip jdk method trace, default value true.")
public void setSkipJDKTrace(boolean skipJDKTrace) {
this.skipJDKTrace = skipJDKTrace;
}
public String getClassPattern() {
return classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public String getConditionExpress() {
return conditionExpress;
}
public boolean isSkipJDKTrace() {
return skipJDKTrace;
}
public boolean isRegEx() {
return isRegEx;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
public List<String> getPathPatterns() {
return pathPatterns;
}
@Override
protected Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
if (pathPatterns == null || pathPatterns.isEmpty()) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
} else {
classNameMatcher = getPathTracingClassMatcher();
}
}
return classNameMatcher;
}
@Override
protected Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
@Override
protected Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
if (pathPatterns == null || pathPatterns.isEmpty()) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
} else {
methodNameMatcher = getPathTracingMethodMatcher();
}
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(CommandProcess process) {
if (pathPatterns == null || pathPatterns.isEmpty()) {
return new TraceAdviceListener(this, process, GlobalOptions.verbose || this.verbose);
} else {
return new PathTraceAdviceListener(this, process);
}
}
/**
* 构造追踪路径匹配
*/
private Matcher<String> getPathTracingClassMatcher() {
List<Matcher<String>> matcherList = new ArrayList<Matcher<String>>();
matcherList.add(SearchUtils.classNameMatcher(getClassPattern(), isRegEx()));
if (null != getPathPatterns()) {
for (String pathPattern : getPathPatterns()) {
if (isRegEx()) {
matcherList.add(new RegexMatcher(pathPattern));
} else {
matcherList.add(new WildcardMatcher(pathPattern));
}
}
}
return new GroupMatcher.Or<String>(matcherList);
}
private Matcher<String> getPathTracingMethodMatcher() {
return new TrueMatcher<String>();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/PerfCounterVO.java | core/src/main/java/com/taobao/arthas/core/command/model/PerfCounterVO.java | package com.taobao.arthas.core.command.model;
/**
* VO for PerfCounterCommand
*
* @author gongdewei 2020/4/27
*/
public class PerfCounterVO {
private String name;
private String units;
private String variability;
private Object value;
public PerfCounterVO() {
}
public PerfCounterVO(String name, Object value) {
this.name = name;
this.value = value;
}
public PerfCounterVO(String name, String units, String variability, Object value) {
this.name = name;
this.units = units;
this.variability = variability;
this.value = value;
}
public void setName(String name) {
this.name = name;
}
public void setUnits(String units) {
this.units = units;
}
public void setVariability(String variability) {
this.variability = variability;
}
public void setValue(Object value) {
this.value = value;
}
public String getName() {
return name;
}
public String getUnits() {
return units;
}
public String getVariability() {
return variability;
}
public Object getValue() {
return value;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ThreadNode.java | core/src/main/java/com/taobao/arthas/core/command/model/ThreadNode.java | package com.taobao.arthas.core.command.model;
import java.time.LocalDateTime;
/**
* Thread root node of TraceCommand
* @author gongdewei 2020/4/29
*/
public class ThreadNode extends TraceNode {
private String threadName;
private long threadId;
private boolean daemon;
private int priority;
private String classloader;
private LocalDateTime timestamp;
private String traceId;
private String rpcId;
public ThreadNode() {
super("thread");
timestamp = LocalDateTime.now();
}
public ThreadNode(String threadName, long threadId, boolean daemon, int priority, String classloader) {
super("thread");
this.threadName = threadName;
this.threadId = threadId;
this.daemon = daemon;
this.priority = priority;
this.classloader = classloader;
timestamp = LocalDateTime.now();
}
public String getThreadName() {
return threadName;
}
public void setThreadName(String threadName) {
this.threadName = threadName;
}
public long getThreadId() {
return threadId;
}
public void setThreadId(long threadId) {
this.threadId = threadId;
}
public boolean isDaemon() {
return daemon;
}
public void setDaemon(boolean daemon) {
this.daemon = daemon;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public String getClassloader() {
return classloader;
}
public void setClassloader(String classloader) {
this.classloader = classloader;
}
public LocalDateTime getTimestamp() {
return timestamp;
}
public void setTimestamp(LocalDateTime timestamp) {
this.timestamp = timestamp;
}
public String getTraceId() {
return traceId;
}
public void setTraceId(String traceId) {
this.traceId = traceId;
}
public String getRpcId() {
return rpcId;
}
public void setRpcId(String rpcId) {
this.rpcId = rpcId;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/OgnlModel.java | core/src/main/java/com/taobao/arthas/core/command/model/OgnlModel.java | package com.taobao.arthas.core.command.model;
import java.util.Collection;
/**
* Data model of OgnlCommand
* @author gongdewei 2020/4/29
*/
public class OgnlModel extends ResultModel {
private ObjectVO value;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
@Override
public String getType() {
return "ognl";
}
public ObjectVO getValue() {
return value;
}
public OgnlModel setValue(ObjectVO value) {
this.value = value;
return this;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public OgnlModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public OgnlModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/DashboardModel.java | core/src/main/java/com/taobao/arthas/core/command/model/DashboardModel.java | package com.taobao.arthas.core.command.model;
import java.util.List;
import java.util.Map;
/**
* Model of 'dashboard' command
* @author gongdewei 2020/4/22
*/
public class DashboardModel extends ResultModel {
private List<ThreadVO> threads;
private Map<String, List<MemoryEntryVO>> memoryInfo;
private List<GcInfoVO> gcInfos;
private RuntimeInfoVO runtimeInfo;
private TomcatInfoVO tomcatInfo;
@Override
public String getType() {
return "dashboard";
}
public List<ThreadVO> getThreads() {
return threads;
}
public void setThreads(List<ThreadVO> threads) {
this.threads = threads;
}
public Map<String, List<MemoryEntryVO>> getMemoryInfo() {
return memoryInfo;
}
public void setMemoryInfo(Map<String, List<MemoryEntryVO>> memoryInfo) {
this.memoryInfo = memoryInfo;
}
public List<GcInfoVO> getGcInfos() {
return gcInfos;
}
public void setGcInfos(List<GcInfoVO> gcInfos) {
this.gcInfos = gcInfos;
}
public RuntimeInfoVO getRuntimeInfo() {
return runtimeInfo;
}
public void setRuntimeInfo(RuntimeInfoVO runtimeInfo) {
this.runtimeInfo = runtimeInfo;
}
public TomcatInfoVO getTomcatInfo() {
return tomcatInfo;
}
public void setTomcatInfo(TomcatInfoVO tomcatInfo) {
this.tomcatInfo = tomcatInfo;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/DumpClassModel.java | core/src/main/java/com/taobao/arthas/core/command/model/DumpClassModel.java | package com.taobao.arthas.core.command.model;
import java.util.Collection;
import java.util.List;
/**
* @author gongdewei 2020/4/21
*/
public class DumpClassModel extends ResultModel {
private List<DumpClassVO> dumpedClasses;
private Collection<ClassVO> matchedClasses;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
public DumpClassModel() {
}
@Override
public String getType() {
return "dump";
}
public List<DumpClassVO> getDumpedClasses() {
return dumpedClasses;
}
public DumpClassModel setDumpedClasses(List<DumpClassVO> dumpedClasses) {
this.dumpedClasses = dumpedClasses;
return this;
}
public Collection<ClassVO> getMatchedClasses() {
return matchedClasses;
}
public DumpClassModel setMatchedClasses(Collection<ClassVO> matchedClasses) {
this.matchedClasses = matchedClasses;
return this;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public DumpClassModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public DumpClassModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/RedefineModel.java | core/src/main/java/com/taobao/arthas/core/command/model/RedefineModel.java | package com.taobao.arthas.core.command.model;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* @author gongdewei 2020/4/16
*/
public class RedefineModel extends ResultModel {
private int redefinitionCount;
private List<String> redefinedClasses;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
public RedefineModel() {
redefinedClasses = new ArrayList<String>();
}
public void addRedefineClass(String className) {
redefinedClasses.add(className);
redefinitionCount++;
}
public int getRedefinitionCount() {
return redefinitionCount;
}
public void setRedefinitionCount(int redefinitionCount) {
this.redefinitionCount = redefinitionCount;
}
public List<String> getRedefinedClasses() {
return redefinedClasses;
}
public void setRedefinedClasses(List<String> redefinedClasses) {
this.redefinedClasses = redefinedClasses;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public RedefineModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public RedefineModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
@Override
public String getType() {
return "redefine";
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/JFRModel.java | core/src/main/java/com/taobao/arthas/core/command/model/JFRModel.java | package com.taobao.arthas.core.command.model;
/**
* @author xulong 2022/7/25
*/
public class JFRModel extends ResultModel {
private String jfrOutput = "";
@Override
public String getType() {
return "jfr";
}
public String getJfrOutput() {
return jfrOutput;
}
public void setJfrOutput(String jfrOutput) {
this.jfrOutput += jfrOutput;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/MemoryModel.java | core/src/main/java/com/taobao/arthas/core/command/model/MemoryModel.java | package com.taobao.arthas.core.command.model;
import java.util.List;
import java.util.Map;
/**
* Model of 'memory' command
* @author hengyunabc 2022-03-01
*/
public class MemoryModel extends ResultModel {
private Map<String, List<MemoryEntryVO>> memoryInfo;
@Override
public String getType() {
return "memory";
}
public Map<String, List<MemoryEntryVO>> getMemoryInfo() {
return memoryInfo;
}
public void setMemoryInfo(Map<String, List<MemoryEntryVO>> memoryInfo) {
this.memoryInfo = memoryInfo;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/TomcatInfoVO.java | core/src/main/java/com/taobao/arthas/core/command/model/TomcatInfoVO.java | package com.taobao.arthas.core.command.model;
import java.util.List;
/**
* Tomcat info of 'dashboard' command
*
* @author gongdewei 2020/4/23
*/
public class TomcatInfoVO {
private List<ConnectorStats> connectorStats;
private List<ThreadPool> threadPools;
public TomcatInfoVO() {
}
public List<ConnectorStats> getConnectorStats() {
return connectorStats;
}
public void setConnectorStats(List<ConnectorStats> connectorStats) {
this.connectorStats = connectorStats;
}
public List<ThreadPool> getThreadPools() {
return threadPools;
}
public void setThreadPools(List<ThreadPool> threadPools) {
this.threadPools = threadPools;
}
public static class ConnectorStats {
private String name;
private double qps;
private double rt;
private double error;
private long received;
private long sent;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getQps() {
return qps;
}
public void setQps(double qps) {
this.qps = qps;
}
public double getRt() {
return rt;
}
public void setRt(double rt) {
this.rt = rt;
}
public double getError() {
return error;
}
public void setError(double error) {
this.error = error;
}
public long getReceived() {
return received;
}
public void setReceived(long received) {
this.received = received;
}
public long getSent() {
return sent;
}
public void setSent(long sent) {
this.sent = sent;
}
}
public static class ThreadPool {
private String name;
private long busy;
private long total;
public ThreadPool() {
}
public ThreadPool(String name, long busy, long total) {
this.name = name;
this.busy = busy;
this.total = total;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getBusy() {
return busy;
}
public void setBusy(long busy) {
this.busy = busy;
}
public long getTotal() {
return total;
}
public void setTotal(long total) {
this.total = total;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/BusyThreadInfo.java | core/src/main/java/com/taobao/arthas/core/command/model/BusyThreadInfo.java | package com.taobao.arthas.core.command.model;
import java.lang.management.LockInfo;
import java.lang.management.MonitorInfo;
import java.lang.management.ThreadInfo;
/**
* Busy thread info, include ThreadInfo fields
*
* @author gongdewei 2020/4/26
*/
public class BusyThreadInfo extends ThreadVO {
private long blockedTime;
private long blockedCount;
private long waitedTime;
private long waitedCount;
private LockInfo lockInfo;
private String lockName;
private long lockOwnerId;
private String lockOwnerName;
private boolean inNative;
private boolean suspended;
private StackTraceElement[] stackTrace;
private MonitorInfo[] lockedMonitors;
private LockInfo[] lockedSynchronizers;
public BusyThreadInfo(ThreadVO thread, ThreadInfo threadInfo) {
this.setId(thread.getId());
this.setName(thread.getName());
this.setDaemon(thread.isDaemon());
this.setInterrupted(thread.isInterrupted());
this.setPriority(thread.getPriority());
this.setGroup(thread.getGroup());
this.setState(thread.getState());
this.setCpu(thread.getCpu());
this.setDeltaTime(thread.getDeltaTime());
this.setTime(thread.getTime());
//thread info
if (threadInfo != null) {
this.setLockInfo(threadInfo.getLockInfo());
this.setLockedMonitors(threadInfo.getLockedMonitors());
this.setLockedSynchronizers(threadInfo.getLockedSynchronizers());
this.setLockName(threadInfo.getLockName());
this.setLockOwnerId(threadInfo.getLockOwnerId());
this.setLockOwnerName(threadInfo.getLockOwnerName());
this.setStackTrace(threadInfo.getStackTrace());
this.setBlockedCount(threadInfo.getBlockedCount());
this.setBlockedTime(threadInfo.getBlockedTime());
this.setInNative(threadInfo.isInNative());
this.setSuspended(threadInfo.isSuspended());
this.setWaitedCount(threadInfo.getWaitedCount());
this.setWaitedTime(threadInfo.getWaitedTime());
}
}
public long getBlockedTime() {
return blockedTime;
}
public void setBlockedTime(long blockedTime) {
this.blockedTime = blockedTime;
}
public long getBlockedCount() {
return blockedCount;
}
public void setBlockedCount(long blockedCount) {
this.blockedCount = blockedCount;
}
public long getWaitedTime() {
return waitedTime;
}
public void setWaitedTime(long waitedTime) {
this.waitedTime = waitedTime;
}
public long getWaitedCount() {
return waitedCount;
}
public void setWaitedCount(long waitedCount) {
this.waitedCount = waitedCount;
}
public LockInfo getLockInfo() {
return lockInfo;
}
public void setLockInfo(LockInfo lockInfo) {
this.lockInfo = lockInfo;
}
public String getLockName() {
return lockName;
}
public void setLockName(String lockName) {
this.lockName = lockName;
}
public long getLockOwnerId() {
return lockOwnerId;
}
public void setLockOwnerId(long lockOwnerId) {
this.lockOwnerId = lockOwnerId;
}
public String getLockOwnerName() {
return lockOwnerName;
}
public void setLockOwnerName(String lockOwnerName) {
this.lockOwnerName = lockOwnerName;
}
public boolean isInNative() {
return inNative;
}
public void setInNative(boolean inNative) {
this.inNative = inNative;
}
public boolean isSuspended() {
return suspended;
}
public void setSuspended(boolean suspended) {
this.suspended = suspended;
}
public StackTraceElement[] getStackTrace() {
return stackTrace;
}
public void setStackTrace(StackTraceElement[] stackTrace) {
this.stackTrace = stackTrace;
}
public MonitorInfo[] getLockedMonitors() {
return lockedMonitors;
}
public void setLockedMonitors(MonitorInfo[] lockedMonitors) {
this.lockedMonitors = lockedMonitors;
}
public LockInfo[] getLockedSynchronizers() {
return lockedSynchronizers;
}
public void setLockedSynchronizers(LockInfo[] lockedSynchronizers) {
this.lockedSynchronizers = lockedSynchronizers;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/MemoryCompilerModel.java | core/src/main/java/com/taobao/arthas/core/command/model/MemoryCompilerModel.java | package com.taobao.arthas.core.command.model;
import java.util.Collection;
import java.util.List;
/**
* @author gongdewei 2020/4/20
*/
public class MemoryCompilerModel extends ResultModel {
private List<String> files;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
public MemoryCompilerModel() {
}
public MemoryCompilerModel(List<String> files) {
this.files = files;
}
public void setFiles(List<String> files) {
this.files = files;
}
public List<String> getFiles() {
return files;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public MemoryCompilerModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public MemoryCompilerModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
@Override
public String getType() {
return "mc";
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ClassLoaderModel.java | core/src/main/java/com/taobao/arthas/core/command/model/ClassLoaderModel.java | package com.taobao.arthas.core.command.model;
import com.taobao.arthas.core.command.klass100.ClassLoaderCommand.ClassLoaderStat;
import com.taobao.arthas.core.command.klass100.ClassLoaderCommand.ClassLoaderUrlStat;
import com.taobao.arthas.core.command.klass100.ClassLoaderCommand.UrlClassStat;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* @author gongdewei 2020/4/21
*/
public class ClassLoaderModel extends ResultModel {
private ClassSetVO classSet;
private List<String> resources;
private ClassDetailVO loadClass;
private List<String> urls;
//classloader -l -t
private List<ClassLoaderVO> classLoaders;
private Boolean tree;
private Map<String, ClassLoaderStat> classLoaderStats;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
//urls stat
private Map<ClassLoaderVO, ClassLoaderUrlStat> urlStats;
// url->classes stat
private ClassLoaderVO classLoader;
private List<UrlClassStat> urlClassStats;
private Boolean urlClassStatsDetail;
public ClassLoaderModel() {
}
@Override
public String getType() {
return "classloader";
}
public ClassSetVO getClassSet() {
return classSet;
}
public ClassLoaderModel setClassSet(ClassSetVO classSet) {
this.classSet = classSet;
return this;
}
public List<String> getResources() {
return resources;
}
public ClassLoaderModel setResources(List<String> resources) {
this.resources = resources;
return this;
}
public ClassDetailVO getLoadClass() {
return loadClass;
}
public ClassLoaderModel setLoadClass(ClassDetailVO loadClass) {
this.loadClass = loadClass;
return this;
}
public List<String> getUrls() {
return urls;
}
public ClassLoaderModel setUrls(List<String> urls) {
this.urls = urls;
return this;
}
public List<ClassLoaderVO> getClassLoaders() {
return classLoaders;
}
public ClassLoaderModel setClassLoaders(List<ClassLoaderVO> classLoaders) {
this.classLoaders = classLoaders;
return this;
}
public Boolean getTree() {
return tree;
}
public ClassLoaderModel setTree(Boolean tree) {
this.tree = tree;
return this;
}
public Map<String, ClassLoaderStat> getClassLoaderStats() {
return classLoaderStats;
}
public ClassLoaderModel setClassLoaderStats(Map<String, ClassLoaderStat> classLoaderStats) {
this.classLoaderStats = classLoaderStats;
return this;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public ClassLoaderModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public ClassLoaderModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
public Map<ClassLoaderVO, ClassLoaderUrlStat> getUrlStats() {
return urlStats;
}
public void setUrlStats(Map<ClassLoaderVO, ClassLoaderUrlStat> urlStats) {
this.urlStats = urlStats;
}
public ClassLoaderVO getClassLoader() {
return classLoader;
}
public ClassLoaderModel setClassLoader(ClassLoaderVO classLoader) {
this.classLoader = classLoader;
return this;
}
public List<UrlClassStat> getUrlClassStats() {
return urlClassStats;
}
public ClassLoaderModel setUrlClassStats(List<UrlClassStat> urlClassStats) {
this.urlClassStats = urlClassStats;
return this;
}
public Boolean getUrlClassStatsDetail() {
return urlClassStatsDetail;
}
public ClassLoaderModel setUrlClassStatsDetail(Boolean urlClassStatsDetail) {
this.urlClassStatsDetail = urlClassStatsDetail;
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ArgumentVO.java | core/src/main/java/com/taobao/arthas/core/command/model/ArgumentVO.java | package com.taobao.arthas.core.command.model;
/**
* @author gongdewei 2020/4/3
*/
public class ArgumentVO {
private String argName;
private boolean required;
private boolean multiValued;
public ArgumentVO() {
}
public ArgumentVO(String argName, boolean required, boolean multiValued) {
this.argName = argName;
this.required = required;
this.multiValued = multiValued;
}
public String getArgName() {
return argName;
}
public void setArgName(String argName) {
this.argName = argName;
}
public boolean isRequired() {
return required;
}
public void setRequired(boolean required) {
this.required = required;
}
public boolean isMultiValued() {
return multiValued;
}
public void setMultiValued(boolean multiValued) {
this.multiValued = multiValued;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/Countable.java | core/src/main/java/com/taobao/arthas/core/command/model/Countable.java | package com.taobao.arthas.core.command.model;
/**
* Item countable for ResultModel
* @author gongdewei 2020/6/8
*/
public interface Countable {
/**
* Get item size of this result model, the value of size is greater than or equal to 1
* @return item size of this result model
*/
int size();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/PwdModel.java | core/src/main/java/com/taobao/arthas/core/command/model/PwdModel.java | package com.taobao.arthas.core.command.model;
/**
* @author gongdewei 2020/5/11
*/
public class PwdModel extends ResultModel {
private String workingDir;
public PwdModel() {
}
public PwdModel(String workingDir) {
this.workingDir = workingDir;
}
@Override
public String getType() {
return "pwd";
}
public String getWorkingDir() {
return workingDir;
}
public void setWorkingDir(String workingDir) {
this.workingDir = workingDir;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ChangeResultVO.java | core/src/main/java/com/taobao/arthas/core/command/model/ChangeResultVO.java | package com.taobao.arthas.core.command.model;
/**
* @author gongdewei 2020/4/16
*/
public class ChangeResultVO {
private String name;
private Object beforeValue;
private Object afterValue;
public ChangeResultVO() {
}
public ChangeResultVO(String name, Object beforeValue, Object afterValue) {
this.name = name;
this.beforeValue = beforeValue;
this.afterValue = afterValue;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object getBeforeValue() {
return beforeValue;
}
public void setBeforeValue(Object beforeValue) {
this.beforeValue = beforeValue;
}
public Object getAfterValue() {
return afterValue;
}
public void setAfterValue(Object afterValue) {
this.afterValue = afterValue;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/MemoryEntryVO.java | core/src/main/java/com/taobao/arthas/core/command/model/MemoryEntryVO.java | package com.taobao.arthas.core.command.model;
/**
* Memory info of 'dashboard' command
*
* @author gongdewei 2020/4/22
*/
public class MemoryEntryVO {
public static final String TYPE_HEAP = "heap";
public static final String TYPE_NON_HEAP = "nonheap";
public static final String TYPE_BUFFER_POOL = "buffer_pool";
private String type;
private String name;
private long used;
private long total;
private long max;
public MemoryEntryVO() {
}
public MemoryEntryVO(String type, String name, long used, long total, long max) {
this.type = type;
this.name = name;
this.used = used;
this.total = total;
this.max = max;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getUsed() {
return used;
}
public void setUsed(long used) {
this.used = used;
}
public long getTotal() {
return total;
}
public void setTotal(long total) {
this.total = total;
}
public long getMax() {
return max;
}
public void setMax(long max) {
this.max = max;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/TimeFragmentVO.java | core/src/main/java/com/taobao/arthas/core/command/model/TimeFragmentVO.java | package com.taobao.arthas.core.command.model;
import java.time.LocalDateTime;
/**
* VO for TimeFragment
* @author gongdewei 2020/4/27
*/
public class TimeFragmentVO {
private Integer index;
private LocalDateTime timestamp;
private double cost;
private boolean isReturn;
private boolean isThrow;
private String object;
private String className;
private String methodName;
private ObjectVO[] params;
private ObjectVO returnObj;
private ObjectVO throwExp;
public TimeFragmentVO() {
}
public Integer getIndex() {
return index;
}
public TimeFragmentVO setIndex(Integer index) {
this.index = index;
return this;
}
public LocalDateTime getTimestamp() {
return timestamp;
}
public TimeFragmentVO setTimestamp(LocalDateTime timestamp) {
this.timestamp = timestamp;
return this;
}
public double getCost() {
return cost;
}
public TimeFragmentVO setCost(double cost) {
this.cost = cost;
return this;
}
public boolean isReturn() {
return isReturn;
}
public TimeFragmentVO setReturn(boolean aReturn) {
isReturn = aReturn;
return this;
}
public boolean isThrow() {
return isThrow;
}
public TimeFragmentVO setThrow(boolean aThrow) {
isThrow = aThrow;
return this;
}
public String getObject() {
return object;
}
public TimeFragmentVO setObject(String object) {
this.object = object;
return this;
}
public String getClassName() {
return className;
}
public TimeFragmentVO setClassName(String className) {
this.className = className;
return this;
}
public String getMethodName() {
return methodName;
}
public TimeFragmentVO setMethodName(String methodName) {
this.methodName = methodName;
return this;
}
public ObjectVO[] getParams() {
return params;
}
public TimeFragmentVO setParams(ObjectVO[] params) {
this.params = params;
return this;
}
public ObjectVO getReturnObj() {
return returnObj;
}
public TimeFragmentVO setReturnObj(ObjectVO returnObj) {
this.returnObj = returnObj;
return this;
}
public ObjectVO getThrowExp() {
return throwExp;
}
public TimeFragmentVO setThrowExp(ObjectVO throwExp) {
this.throwExp = throwExp;
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/CommandOptionVO.java | core/src/main/java/com/taobao/arthas/core/command/model/CommandOptionVO.java | package com.taobao.arthas.core.command.model;
/**
* @author gongdewei 2020/4/3
*/
public class CommandOptionVO {
/**
* the option long name.
*/
private String longName;
/**
* the option short name.
*/
private String shortName;
/**
* The option description.
*/
private String description;
/**
* whether or not the option receives a single value or multiple values.
*/
private boolean acceptValue;
public CommandOptionVO() {
}
public String getLongName() {
return longName;
}
public void setLongName(String longName) {
this.longName = longName;
}
public String getShortName() {
return shortName;
}
public void setShortName(String shortName) {
this.shortName = shortName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isAcceptValue() {
return acceptValue;
}
public void setAcceptValue(boolean acceptValue) {
this.acceptValue = acceptValue;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ResetModel.java | core/src/main/java/com/taobao/arthas/core/command/model/ResetModel.java | package com.taobao.arthas.core.command.model;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
/**
* @author gongdewei 2020/6/22
*/
public class ResetModel extends ResultModel {
private EnhancerAffectVO affect;
public ResetModel(EnhancerAffectVO affect) {
this.affect = affect;
}
public ResetModel(EnhancerAffect affect) {
this.affect = EnhancerModelFactory.createEnhancerAffectVO(affect);
}
@Override
public String getType() {
return "reset";
}
public ResetModel affect(EnhancerAffect affect) {
this.affect = EnhancerModelFactory.createEnhancerAffectVO(affect);
return this;
}
public EnhancerAffectVO getAffect() {
return affect;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/RowAffectModel.java | core/src/main/java/com/taobao/arthas/core/command/model/RowAffectModel.java | package com.taobao.arthas.core.command.model;
import com.taobao.arthas.core.util.affect.RowAffect;
/**
* @author gongdewei 2020/4/8
*/
public class RowAffectModel extends ResultModel {
private RowAffect affect;
public RowAffectModel() {
}
public RowAffectModel(RowAffect affect) {
this.affect = affect;
}
@Override
public String getType() {
return "row_affect";
}
public int getRowCount() {
return affect.rCnt();
}
public RowAffect affect() {
return affect;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/TraceNode.java | core/src/main/java/com/taobao/arthas/core/command/model/TraceNode.java | package com.taobao.arthas.core.command.model;
import java.util.ArrayList;
import java.util.List;
/**
* Abstract Node of TraceCommand
* @author gongdewei 2020/4/28
*/
public abstract class TraceNode {
protected TraceNode parent;
protected List<TraceNode> children;
/**
* node type: method,
*/
private String type;
/**
* 备注
*/
private String mark;
/**
* TODO marks数量的作用？是否可以去掉
*/
private int marks = 0;
public TraceNode(String type) {
this.type = type;
}
public void addChild(TraceNode child) {
if (children == null) {
children = new ArrayList<TraceNode>();
}
this.children.add(child);
child.setParent(this);
}
public void setMark(String mark) {
this.mark = mark;
marks++;
}
public String getMark() {
return mark;
}
public Integer marks() {
return marks;
}
public void begin() {
}
public void end() {
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public TraceNode parent() {
return parent;
}
public void setParent(TraceNode parent) {
this.parent = parent;
}
public List<TraceNode> getChildren() {
return children;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/EnhancerModelFactory.java | core/src/main/java/com/taobao/arthas/core/command/model/EnhancerModelFactory.java | package com.taobao.arthas.core.command.model;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* Factory class for creating EnhancerModel and EnhancerAffectVO from EnhancerAffect.
* The base EnhancerModel and EnhancerAffectVO are defined in arthas-model module.
*
* @author gongdewei 2020/7/20
*/
public class EnhancerModelFactory {
public static EnhancerModel create(EnhancerAffect affect, boolean success) {
return new EnhancerModel(createEnhancerAffectVO(affect), success);
}
public static EnhancerModel create(EnhancerAffect affect, boolean success, String message) {
return new EnhancerModel(createEnhancerAffectVO(affect), success, message);
}
/**
* Create EnhancerAffectVO from EnhancerAffect.
* This method is public so other classes like ResetModel can use it.
*/
public static EnhancerAffectVO createEnhancerAffectVO(EnhancerAffect affect) {
if (affect == null) {
return new EnhancerAffectVO(-1, 0, 0, -1);
}
EnhancerAffectVO vo = new EnhancerAffectVO(
affect.cost(),
affect.mCnt(),
affect.cCnt(),
affect.getListenerId()
);
vo.setThrowable(affect.getThrowable());
vo.setOverLimitMsg(affect.getOverLimitMsg());
if (GlobalOptions.isDump) {
List<String> classDumpFiles = new ArrayList<String>();
for (File classDumpFile : affect.getClassDumpFiles()) {
classDumpFiles.add(classDumpFile.getAbsolutePath());
}
vo.setClassDumpFiles(classDumpFiles);
}
if (GlobalOptions.verbose) {
List<String> methods = new ArrayList<String>();
methods.addAll(affect.getMethods());
vo.setMethods(methods);
}
return vo;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/RuntimeInfoVO.java | core/src/main/java/com/taobao/arthas/core/command/model/RuntimeInfoVO.java | package com.taobao.arthas.core.command.model;
/**
* Dashboard - Runtime
*
* @author gongdewei 2020/4/22
*/
public class RuntimeInfoVO {
private String osName;
private String osVersion;
private String javaVersion;
private String javaHome;
private double systemLoadAverage;
private int processors;
private long uptime;
private long timestamp;
public RuntimeInfoVO() {
}
public String getOsName() {
return osName;
}
public void setOsName(String osName) {
this.osName = osName;
}
public String getOsVersion() {
return osVersion;
}
public void setOsVersion(String osVersion) {
this.osVersion = osVersion;
}
public String getJavaVersion() {
return javaVersion;
}
public void setJavaVersion(String javaVersion) {
this.javaVersion = javaVersion;
}
public String getJavaHome() {
return javaHome;
}
public void setJavaHome(String javaHome) {
this.javaHome = javaHome;
}
public double getSystemLoadAverage() {
return systemLoadAverage;
}
public void setSystemLoadAverage(double systemLoadAverage) {
this.systemLoadAverage = systemLoadAverage;
}
public int getProcessors() {
return processors;
}
public void setProcessors(int processors) {
this.processors = processors;
}
public long getUptime() {
return uptime;
}
public void setUptime(long uptime) {
this.uptime = uptime;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/JadModel.java | core/src/main/java/com/taobao/arthas/core/command/model/JadModel.java | package com.taobao.arthas.core.command.model;
import java.util.Collection;
import java.util.NavigableMap;
/**
* @author gongdewei 2020/4/22
* @author hengyunabc 2021-02-23
*/
public class JadModel extends ResultModel {
private ClassVO classInfo;
private String location;
private String source;
private NavigableMap<Integer,Integer> mappings;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
//match multiple classes
private Collection<ClassVO> matchedClasses;
@Override
public String getType() {
return "jad";
}
public JadModel() {
}
public ClassVO getClassInfo() {
return classInfo;
}
public void setClassInfo(ClassVO classInfo) {
this.classInfo = classInfo;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public NavigableMap<Integer, Integer> getMappings() {
return mappings;
}
public void setMappings(NavigableMap<Integer, Integer> mappings) {
this.mappings = mappings;
}
public Collection<ClassVO> getMatchedClasses() {
return matchedClasses;
}
public void setMatchedClasses(Collection<ClassVO> matchedClasses) {
this.matchedClasses = matchedClasses;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public JadModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public JadModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/RetransformModel.java | core/src/main/java/com/taobao/arthas/core/command/model/RetransformModel.java | package com.taobao.arthas.core.command.model;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.taobao.arthas.core.command.klass100.RetransformCommand.RetransformEntry;
/**
*
* @author hengyunabc 2021-01-06
*
*/
public class RetransformModel extends ResultModel {
private int retransformCount;
private List<String> retransformClasses;
private Collection<ClassLoaderVO> matchedClassLoaders;
private String classLoaderClass;
private List<RetransformEntry> retransformEntries;
private RetransformEntry deletedRetransformEntry;
// private List<ClassVO> trigger
// List<ClassVO> classVOs = ClassUtils.createClassVOList(matchedClasses);
public RetransformModel() {
}
public void addRetransformClass(String className) {
if (retransformClasses == null) {
retransformClasses = new ArrayList<String>();
}
retransformClasses.add(className);
retransformCount++;
}
public int getRetransformCount() {
return retransformCount;
}
public void setRetransformCount(int retransformCount) {
this.retransformCount = retransformCount;
}
public List<String> getRetransformClasses() {
return retransformClasses;
}
public void setRetransformClasses(List<String> retransformClasses) {
this.retransformClasses = retransformClasses;
}
public String getClassLoaderClass() {
return classLoaderClass;
}
public RetransformModel setClassLoaderClass(String classLoaderClass) {
this.classLoaderClass = classLoaderClass;
return this;
}
public Collection<ClassLoaderVO> getMatchedClassLoaders() {
return matchedClassLoaders;
}
public RetransformModel setMatchedClassLoaders(Collection<ClassLoaderVO> matchedClassLoaders) {
this.matchedClassLoaders = matchedClassLoaders;
return this;
}
public List<RetransformEntry> getRetransformEntries() {
return retransformEntries;
}
public void setRetransformEntries(List<RetransformEntry> retransformEntries) {
this.retransformEntries = retransformEntries;
}
public RetransformEntry getDeletedRetransformEntry() {
return deletedRetransformEntry;
}
public void setDeletedRetransformEntry(RetransformEntry deletedRetransformEntry) {
this.deletedRetransformEntry = deletedRetransformEntry;
}
@Override
public String getType() {
return "retransform";
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ClassSetVO.java | core/src/main/java/com/taobao/arthas/core/command/model/ClassSetVO.java | package com.taobao.arthas.core.command.model;
import java.util.Collection;
/**
* @author gongdewei 2020/4/21
*/
public class ClassSetVO implements Countable {
private ClassLoaderVO classloader;
private Collection<String> classes;
private int segment;
public ClassSetVO(ClassLoaderVO classloader, Collection<String> classes) {
this(classloader, classes, 0);
}
public ClassSetVO(ClassLoaderVO classloader, Collection<String> classes, int segment) {
this.classloader = classloader;
this.classes = classes;
this.segment = segment;
}
public ClassLoaderVO getClassloader() {
return classloader;
}
public void setClassloader(ClassLoaderVO classloader) {
this.classloader = classloader;
}
public Collection<String> getClasses() {
return classes;
}
public void setClasses(Collection<String> classes) {
this.classes = classes;
}
public int getSegment() {
return segment;
}
public void setSegment(int segment) {
this.segment = segment;
}
@Override
public int size() {
return classes != null ? classes.size() : 1;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/VMOptionModel.java | core/src/main/java/com/taobao/arthas/core/command/model/VMOptionModel.java | package com.taobao.arthas.core.command.model;
import com.sun.management.VMOption;
import java.util.List;
/**
* @author gongdewei 2020/4/15
*/
public class VMOptionModel extends ResultModel {
private List<VMOption> vmOptions;
private ChangeResultVO changeResult;
public VMOptionModel() {
}
public VMOptionModel(List<VMOption> vmOptions) {
this.vmOptions = vmOptions;
}
public VMOptionModel(ChangeResultVO changeResult) {
this.changeResult = changeResult;
}
@Override
public String getType() {
return "vmoption";
}
public List<VMOption> getVmOptions() {
return vmOptions;
}
public void setVmOptions(List<VMOption> vmOptions) {
this.vmOptions = vmOptions;
}
public ChangeResultVO getChangeResult() {
return changeResult;
}
public void setChangeResult(ChangeResultVO changeResult) {
this.changeResult = changeResult;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/ThreadVO.java | core/src/main/java/com/taobao/arthas/core/command/model/ThreadVO.java | package com.taobao.arthas.core.command.model;
import java.lang.Thread.State;
/**
* Thread VO of 'dashboard' and 'thread' command
*
* @author gongdewei 2020/4/22
*/
public class ThreadVO {
private long id;
private String name;
private String group;
private int priority;
private State state;
private double cpu;
private long deltaTime;
private long time;
private boolean interrupted;
private boolean daemon;
public ThreadVO() {
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGroup() {
return group;
}
public void setGroup(String group) {
this.group = group;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
public double getCpu() {
return cpu;
}
public void setCpu(double cpu) {
this.cpu = cpu;
}
public long getDeltaTime() {
return deltaTime;
}
public void setDeltaTime(long deltaTime) {
this.deltaTime = deltaTime;
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
public boolean isInterrupted() {
return interrupted;
}
public void setInterrupted(boolean interrupted) {
this.interrupted = interrupted;
}
public boolean isDaemon() {
return daemon;
}
public void setDaemon(boolean daemon) {
this.daemon = daemon;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ThreadVO threadVO = (ThreadVO) o;
if (id != threadVO.id) return false;
return name != null ? name.equals(threadVO.name) : threadVO.name == null;
}
@Override
public int hashCode() {
int result = (int) (id ^ (id >>> 32));
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/model/VersionModel.java | core/src/main/java/com/taobao/arthas/core/command/model/VersionModel.java | package com.taobao.arthas.core.command.model;
public class VersionModel extends ResultModel {
private String version;
@Override
public String getType() {
return "version";
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.