Ausführliche Erläuterung der Online-Fehlerbehebung von BTrace für Java

Was ist BTrace?

BTrace ist ein Killer-Tool zum Überprüfen und Lösen von Online-Problemen. BTrace kann alle Informationen während der Ausführung des Programms durch das Schreiben von Skripten abrufen, und das ist nicht erforderlich um den Dienst neu zu starten, ja, es ist nicht erforderlich, den Dienst neu zu starten. Nachdem Sie das Skript geschrieben haben, können Sie es direkt mit dem Befehl ausführen, ohne den ursprünglichen Programmcode anzutasten.

Prinzip

Im Allgemeinen basiert BTrace auf der dynamischen Bytecode-Änderungstechnologie (Hotswap), um die Verfolgung und Ausführung von Laufzeit-Java-Programmen zu realisieren. ersetzen. Das allgemeine Prinzip kann durch die folgende Formel beschrieben werden: Client(Java compile api + attach api) + Agent（脚本解析引擎 + ASM + JDK6 Instumentation） + SocketTatsächlich verwendet BTrace die Java-Attach-API, um agent.jar anzuhängen, und verwendet dann die Skript-Parsing-Engine + ASM, um den Bytecode des neu zu schreiben angegebene Klasse und verwenden Sie dann das Instrument, um die ursprüngliche Klasse zu ersetzen.

Installation und Konfiguration

Diese Installation und Konfiguration wird unter Linux Ubuntu 14.04 durchgeführt. Die neueste Version von BTrace ist derzeit 1.3.9 und der Code wird auf [github] gehostet. Der erste Schritt besteht darin, die Release-Version btrace-bin-1.3.9.tgz von Github herunterzuladen. Die Zip-Version hat kein Build-Verzeichnis. Der zweite Schritt besteht darin, btrace-bin-1.3.9.tgz in ein Verzeichnis zu entpacken, z. B. /home/fengzheng/soft/btrace. In diesem Schritt ist es tatsächlich einsatzbereit, Sie müssen jedoch bei der Ausführung vor dem btrace-Befehl „absolute“ hinzufügen Wenn Sie das Skript in einem beliebigen Verzeichnis ausführen möchten, fahren Sie mit dem dritten Schritt fort. Die konfigurierten Umgebungsvariablen umfassen beispielsweise und JAVA_HOME lautet wie folgt: BTRACE_HOME

export JAVA_HOME=/home/fengzheng/soft/jdk1.8.0_111
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib  
export PATH=${JAVA_HOME}/bin:$PATH
export BTRACE_HOME=/home/fengzheng/soft/btrace
export PATH=$PATH:$BTRACE_HOME/bin

Führen Sie dann den Befehl aus, um das zu erstellen Umgebungsvariablen werden sofort wirksam. Führen Sie als Nächstes den Befehl source /etc/profile in einem beliebigen Verzeichnis aus und er wird erfolgreich ausgeführt. btrace

Einfacher Testfall

btrace Die einfachste Syntax ist , daher müssen Sie die Prozess-ID des btrace $pid script.java-Programms kennen, das Sie erkennen möchten, und Schreiben Sie dann ein Erkennungsskript. Das ist alles. Java

1. Schreiben Sie hier eine Endlosschleife, um alle 5 Sekunden eine Reihe von Berechnungsergebnissen auszugeben. Java

package kite.lab.utils;
/**
 * NumberUtil
 *
 * @author fengzheng
 * @date 2017/2/15
 */
public class NumberUtil {

    public int sum(){
        int result = 0;
        for(int i = 0; i< 100; i++){
            result += i * i;
        }
        return result;
    }

    public static void main(String[] args){
        while (true) {
            Thread.currentThread().setName("计算");
            NumberUtil util = new NumberUtil();
            int result = util.sum();
            System.out.println(result);
            try {
                Thread.sleep(5000);
            }catch (InterruptedException e){

            }
        }
    }
}

Übrigens, der Prozess des Kompilierens und Ausführens von Java über die Befehlszeile:

Kompilieren Sie : , suchen Sie das Verzeichnis, in dem sich NumberUtil.java befindet, und führen Sie dann diese Befehlszeile aus. Sie wird generiert im aktuellen Verzeichnis (. gibt das aktuelle Verzeichnis an) Die im Paketnamen angezeigte Verzeichnisstruktur, kite/lab/utils/NumberUtil.classjavac -d . NumberUtil.java

Ausführen: kann java kite.lab.utils.NumberUtil　2 sein. Nachdem Sie das obige Programm ausgeführt haben, können Sie

Befehl zum Überprüfen der PID (welches Konto im Allgemeinen zum Starten des Programms verwendet wird, welches Konto zum Ausführen von JPS verwendet werden soll (außer Root-Konto), führen Sie den Befehl JPS aus, um die folgenden Ergebnisse anzuzeigen:

jps

3. Sie können sehen, dass der gerade ausgeführte Java-Prozess 10860 ist.

root@ubuntu:/home/fengzheng/codes/btrace# jps
10906 Jps
10860 NumberUtil

Der Inhalt des Skripts lautet wie folgt: .RETURN). Ende der Ausführung) Ergebnisse und Stapelinformationen ausgeben

5. Vorkompilierung: Sie können den Vorkompilierungsbefehl verwenden, um die Richtigkeit des Skripts vor der Ausführung zu überprüfen. Der Vorkompilierungsbefehl ist btracec, also A Javac-ähnlicher Befehl, btracec NumberUtilBTrace.java

package kite;
import com.sun.btrace.annotations.*;
import static com.sun.btrace.BTraceUtils.Strings.strcat;
import static com.sun.btrace.BTraceUtils.jstack;
import static com.sun.btrace.BTraceUtils.println;
import static com.sun.btrace.BTraceUtils.str;

/**
 * NumberUtilBTrace
 *
 * @author fengzheng
 * @date 2017/6/20
 */
@BTrace
public class NumberUtilBTrace {

    @OnMethod(
            clazz="kite.lab.utils.NumberUtil",
            method="sum",
            location=@Location(Kind.RETURN)
    )
    public static void func(@Return int result) {
        println("trace: =======================");
        println(strcat("result:", str(result)));
        jstack();
    }
}

6. Rufen Sie die Befehlszeilenausführung auf, btrace 10860 NumberUtilBTrace.java, (wenn Sie es lokal speichern möchten Datei, Sie können den Umleitungsbefehl btrace 10860 NumberUtilBTrace.java > verwenden, um die folgenden Informationen auszudrucken

7. Drücken Sie Strg + C, eine Aufforderung zum Beenden wird angezeigt, und drücken Sie dann 1, um den Vorgang zu beenden

Nutzungsszenarien

trace: =======================
result:328350
kite.lab.utils.NumberUtil.sum(NumberUtil.java:16)
kite.lab.utils.NumberUtil.main(NumberUtil.java:27)

BTrace 是一个事后工具，所谓事后工具就是在服务已经上线了，但是发现存在以下问题的时候，可以用 BTrace。

1. 比如哪些方法执行太慢，例如监控执行时间超过1s的方法

2. 查看哪些方法调用了 System.gc() ，调用栈是怎样的

3. 查看方法参数或对象属性

4. 哪些方法发生了异常

多说一点，为了更好解决问题，最好还要配合事前准备和进行中监控，事前准备就是埋点嘛，在一些可能出现问题的方法中进行日志输出，进行中监控就是利用一些实时监控工具，例如 VisualVM 、jmc 这些带界面的工具或者 jdk 提供的命令行工具等，再高级一点的就是利用 Graphite 这样的Metrics 工具配合 web 界面展示出来。

使用限制

 

为了保证trace语句只读,最小化对被检测程序造成影响， BTrace对trace脚本有一些限制(比如不能改变被trace代码中的状态)

• BTrace class不能新建类, 新建数组, 抛异常, 捕获异常,

• 不能调用实例方法以及静态方法(com.sun.btrace.BTraceUtils除外)

• 不能将目标程序和对象赋值给BTrace的实例和静态field

• 不能定义外部, 内部, 匿名, 本地类

• 不能有同步块和方法

• 不能有循环

• 不能实现接口, 不能扩展类

• 不能使用assert语句, 不能使用class字面值

拦截方法定义

@OnMethod 可以指定 clazz 、method、location。由此组成了在什么时机（location 决定）监控某个类/某些类（clazz 决定）下的某个方法/某些方法(method 决定)。

如何定位

1. 精准定位

直接定位到一个类下的一个方法，上面测试用的例子就是

2. 正则表达式定位

正则表达式在两个"/" 之间，例如下面的例子,监控 javax.swing 包下的所有方法，注意正式环境中，范围尽可能小一点，太大了性能会有影响。

 

@OnMethod(clazz="/javax\\.swing\\..*/", method="/.*/")
public static void swingMethods( @ProbeClassName String probeClass, @ProbeMethodName String probeMethod) {
   print("entered " + probeClass + "."  + probeMethod);
}

通过在拦截函数的定义里注入@ProbeClassName String probeClass, @ProbeMethodName String probeMethod 参数，告诉脚本实际匹配到的类和方法名。

3. 按接口或继承类定位

例如要匹配继承或实现了 com.kite.base 的接口或基类的，只要在类前加上 + 号就可以了，例如

@OnMethod(clazz="+com.kite.base", method="doSome")

4. 按注解定位

在前面加上 @ 即可，例如@OnMethod(clazz="@javax.jws.WebService", method="@javax.jws.WebMethod")　　

拦截时机

拦截时机由 location 决定，当然也可为同一个定位加入多个拦截时机，即可以在进入方法时拦截、方法返回时拦截、抛出异常时拦截

1. Kind.Entry与Kind.Return

分别表示函数的开始和返回，不写 location 的情况下，默认为 Kind.Entry,仅获取参数值，可以用 Kind.Entry ，要获取返回值或执行时间就要用 Kind.Return

2. Kind.Error, Kind.Throw和 Kind.Catch

表示异常被 throw 、异常被捕获还有异常发生但是没有被捕获的情况，在拦截函数的参数定义里注入一个Throwable的参数，代表异常

@OnMethod(clazz = "com.kite.demo", location = @Location(value = Kind.LINE, line = 20))
public static void onBind() {
   println("执行到第20行");
}

@OnMethod(clazz = "java.net.ServerSocket", method = "bind", location =@Location(Kind.ERROR)) 
public static void onBind(Throwable exception, @Duration long duration){ }

3. Kind.Call 和 Kind.Line　　

Kind.Call 表示被监控的方法调用了哪些其他方法，例如：

@OnMethod(clazz = "com.kite",
            method = "login",
            location = @Location(value = Kind.CALL, clazz = "/.*/", method = "/.*/", where = Where.AFTER))
    public static void onBind(@Self Object self, @TargetInstance Object instance, @TargetMethodOrField String method, @Duration long duration){
        println(strcat("self: ", str(self)));
        println(strcat("instance: ", str(instance)));
        println(strcat("method: ", str(method)));
        println(strcat("duration(ms): ", str(duration / 1000000)));
    }

@Self 表示当前监控的函数所在类，如果是静态类则为空，@TargetInstance 表示函数中调用的方法或属性所在的类，如果是静态方法则为空，@TargetMethodOrField 表示调用的方法或属性，如果要获取执行时间，那么 where 必须设置为 Where.AFTER

Kind.Line 监测类是否执行到了设置的行数，例如：

@OnMethod(clazz = "com.kite.demo", location = @Location(value = Kind.LINE, line = 20))
public static void onBind() {

   println("执行到第20行");

}

几个例子

查看谁调用了GC

@OnMethod(clazz = "java.lang.System", method = "gc")
    public static void onSystemGC() {
        println("entered System.gc()");
        jstack();
    }

打印耗时超过100ms的方法

@OnMethod(clazz = "/com\\.kite\\.controller\\..*/",method = "/.*/",location = @Location(Kind.RETURN))
    public static void slowQuery(@ProbeClassName String pcn,@ProbeMethodName String probeMethod, @Duration long duration){
        if(duration > 1000000 * 100){
            println(strcat("类：", pcn));
            println(strcat("方法：", probeMethod));
            println(strcat("时长：", str(duration / 1000000)));
        }
    }

BTrace 提供了一系列的 sample, 可到 github 上查看。

注意问题

如果出现 Unable to open socket file: target process not responding or HotSpot VM not loaded 这个问题，可能的原因是执行 BTrace 脚本的用户和 Java 进程运行的用户不是同一个，使用 ps -aux | grep $pid查看一下 Java 进程的执行用户，保证和 BTrace 脚本执行用户相同即可　

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Online-Fehlerbehebung von BTrace für Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!