Unified exception reporting practice based on bytecode

Unified exception reporting practice based on bytecode

[toc]

One 、 Preface

In our daily work , There will always be all kinds of “ error ” And sudden “ abnormal ”. No matter how much preparation we make , How many tests , These exceptions always appear at some point in time , If not handled properly or in a timely manner , It often leads to other new problems . So we should always pay attention to these traps and need a set of “ Best practices ” To establish a perfect exception handling mechanism . So how can we quickly 、 Locate exactly where the exception occurred , And some simple abnormal information to facilitate the research and development of positioning problems ？ Let's follow me to see how Zhuanzhuan Zhongtai gracefully monitors and reports exceptions .

Two 、 Exception introduction

2.1  Understanding anomalies

The program is running , Something unexpected happened , Prevents the normal execution of the program , This condition is called an exception . After exception , Manual intervention is often required , Otherwise, it will expand the influence surface of the anomaly . Usually when handling exceptions , The following problems need to be solved 3 A question ：

• What's going on ？

• Who will handle exceptions ？

• How to handle exceptions ？

2.2 Java Classification of exceptions

JDK There is a complete exception mechanism in , All exceptions are Throwable Subclasses of , It is divided into Error（ Fatal abnormality ） and  Exception( Non fatal anomalies ).

Error

Is a very special exception type , His presence marks an uncontrollable error in the system , Such as ：StackOverflowError、OutOfMemoryError, The program cannot handle it , Only manual intervention

Exception

It is divided into

ckecked abnormal

（ B. abnormal ） and  

uncheck abnormal

（ Undetected abnormal ）,checked Exceptions need to be handled explicitly in the code , Otherwise the compilation will report an error .uncheck Exceptions are runtime exceptions , They all inherit RuntimeException, No program is required to capture and process the display .

2.3  Exception handling process

2.4  Principles of exception throwing and catching

• Unnecessary use of exceptions

• Throw an exception using a descriptive message

• Exceptions within your ability must be handled

• Exceptions should be ignored with reason

2.5  know try/catch/finally

When it comes to exception handling , I have to mention try/catch/finally.try It can't exist alone , Or match catch, Or match finally, Or there are three . 1、try Code block ： Monitor code block execution , If the corresponding exception is found, jump to catch, If there is no catch Then go straight to finally block . 2、catch Code block ： If a corresponding exception occurs, the code inside will be executed , Or deal with , Or throw it up . 3、finally Code block : No matter whether there is any abnormality , All must be carried out , Generally used to clean up resources , Release connections, etc . However, there are several cases where the code will not execute here .

• The code execution process has not entered try Code block .

• Code in try Life and death cycle in code block 、 Deadlock, etc .

• stay try In the code block System.exit() operation .

3、 ... and 、 exception handling

3.1  Best practices for handling exceptions

• When you need to throw an exception up , Exceptions with business meaning need to be defined according to the current business scenario , Give priority to exceptions defined within the industry or defined within the team . For example, in use dubbo Throw when the remote service call times out DubboTimeoutException, Instead of putting RuntimeException Throw out .

• Please do not leave finally Used in code blocks return sentence , Avoid complicated judgment of return value .

• Catch exception specific subclasses , instead of Exception, Not to mention throwable. This will catch all the errors , Include JVM A fatal error thrown that cannot be handled .

• Don't neglect any abnormality （catch I don't do anything about it ）, Even now, we can make sure that it doesn't affect the normal operation of the logic , But no one can guarantee how the code will change in the future , Don't dig a hole for yourself .

• Don't use exceptions as control processes , This is a very strange and influential practice .

• Cleaning up resources , Release connections and other operations must be placed in finally Block of code , Prevent memory leaks , If finally Block processing has more logic and modularity , We can encapsulate tool method calls , The code will be simpler .

3.2  Turn to the practice of abnormal monitoring and reporting

Let's take a look at the pseudo code to see what we usually do when dealing with exceptions

 public String doSomething(String arg) {
 try {
 return method1(arg);
 } catch (Exception e) {
 log.error("call method1 error msg={}", e.getMessage());
 // do  Alarm related logic
 } finally {
 // do close resource
 }
 return null;
 }


Generally we will be in catch Print the error log in the code block , Register some information about buried sites , Or call the monitoring alarm component to report the error alarm information , The warning system is used to notify the R & D personnel to check and locate the errors .

Let's analyze if there is anything that can be optimized in the above way , be-all catch The operations we do in the code block are similar , So what kind of method can we use for unified processing ？ When you see this, you will think , You can use aop The cut surface shall be packaged and processed uniformly , It's a plan , But this requires us to write aspects ,

We can also deal with it in a non intrusive, unified way , This is it.

Bytecode enhancement

technology . There are three main frameworks for bytecode enhancement ;

ASM

、

Javassist

、

ByteCode

, Each has its own advantages and disadvantages . This article will not discuss their advantages and disadvantages , What we chose is ASM+javaAgent To achieve  .

ASM

, It's a  Java  Bytecode control framework . It can be used to dynamically generate classes or enhance the function of existing classes .ASM  Binary can be generated directly  class  file , You can also load the  Java  Dynamic change of class behavior before virtual machine .Java class  Stored in a strictly formatted  .class  In the document , These class files have enough metadata to parse all the elements in the class ： Class name 、 Method 、 Properties and  Java  Bytecode （ Instructions ）.ASM  After reading in information from class file , Ability to change class behavior , Analysis information , Can even generate new classes according to user requirements . To put it bluntly asm It is modified directly by bytecode class file . Besides  asm  Can operate bytecode , also javassist and Byte-code etc. , They are worse than  asm  Be simple , But the execution efficiency is still  asm  high . because  asm  It uses instructions to control bytecode directly .

JavaAgent

, It's a probe technology that you can use  

premain

  Method , Bytecode enhancement for the specified method during class loading . In fact, each of your classes is ultimately the execution of bytecode instructions , This enhanced method can output the information we want . This is equivalent to the time-consuming output of some methods when you hard code , Log and other information .

3.3 ASM+javaAgent Realize unified reporting of abnormal information

To write javaAgent

 public static void premain(String arg, Instrumentation inst) {
 LOG.info("******** AgentApplication.premain executing, String Param: {}********", arg);
 inst.addTransformer(new CustomClassFileTransformer(), true);
 LOG.info("******** AgentApplication premain executed ********");
 }


To write CustomClassFileTransformer Realization ClassFileTransformer rewrite transform Method , Determine the classes that need to be enhanced

 @Override
 public byte[] transform(ClassLoader loader,
 String className,
 Class<?> classBeingRedefined,
 ProtectionDomain protectionDomain,
 byte[] classfileBuffer) {
 //  Determine whether the current class needs to be enhanced
 if (!needEnhance(className)) {
 return classfileBuffer;
 }
 try {
 ClassReader cr = new ClassReader(className);
 ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
 CustomClassVisitor classVisitor = new CustomClassVisitor(cw);
 cr.accept(classVisitor, ClassReader.EXPAND_FRAMES);
 return cw.toByteArray();
 } catch (IOException e) {
 LOG.warn(&quot;desc=CustomClassFileTransformer.transform, className:{} Exception:{}&quot;, className, e);
 }
 return classfileBuffer;
 }


To write CustomClassVisitor Inherit  ClassVisitor Enhance bytecode method

 @Override
 public MethodVisitor visitMethod(int access, String methodName, String desc, String signature, String[] exceptions) {
 MethodVisitor mv = cv.visitMethod(access, methodName, desc, signature, exceptions);
 //  Skip ignored methods , Such as the construction method  <init>, toString etc.
 if (!SKIP_METHODS.contains(methodName) && mv != null) {
 mv = new CustomMethodVisitor(mv, className, methodName);
 }
 return mv;
 }


To write CustomMethodVisitor Inherit MethodVisitor again  visitTryCatchBlock and visitLineNumber Conduct try-catch Problem location and processing enhancements .

 @Override
 public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
 exceptionHandlers.add(handler);
 super.visitTryCatchBlock(start, end, handler, type);
 }


 @Override
 public void visitLineNumber(int line, Label start) {
 if (exceptionHandlers.contains(start)) {
 ExceptionProcessor.injectHandleLogic(this, className, methodName, line);
 }
 super.visitLineNumber(line, start);
 }
 /**
 *  Injection processing logic
 *  Call exception handling methods  {@link ExceptionProcessor#process(Throwable, String, String, int)}
 *
 * @param visitor  Method visitor
 * @param className  Class name
 * @param methodName  Method name
 * @param lineNumber catch It starts with the block   Line number （ There may be more than one in a method catch block , Index Introduction lineNumber, Identify abnormal position with accurate marker ）
 */
 public static void injectHandleLogic(MethodVisitor visitor, String className, String methodName, int lineNumber) {
 visitor.visitInsn(DUP);
 visitor.visitLdcInsn(className);
 visitor.visitLdcInsn(methodName);
 visitor.visitLdcInsn(lineNumber);
 visitor.visitMethodInsn(INVOKESTATIC, EXCEPTION_HANDLE_CLASS, EXCEPTION_HANDLE_METHOD, EXCEPTION_HANDLE_PARAM, false);
 }
/**
 *  Logic for handling exceptions
 *  In this method, we can clearly know the class throwing exceptions 、 Method 、 Line number and other abnormal information , Easy to assemble and report information, convenient for R & D positioning
 *  Please do not modify the method signature  {@link ExceptionProcessor#injectHandleLogic(MethodVisitor, String, String, int)} Call in
 *
 * @param exception  Exception to handle
 * @param className  Class name
 * @param methodName  Method name
 * @param lineNumber catch The line number at the beginning of the block
 * @param <T>  Abnormal paradigm
 */
 public static <T extends Throwable> void process(T exception, String className, String methodName, int lineNumber) {
 try {
 className = className.replace(File.separator, &quot;.&quot;);
 String itemName = generateItemNameAfterFilter(exception.getClass().getSimpleName(), className, methodName);
 if (StringUtil.isEmpty(itemName)) {
 return;
 }
 //  Alarm logic processing
 ZzMonitor.sumWithAlarm(itemName, 1, String.valueOf(lineNumber), true);
 } catch (RuntimeException e) {
 LOG.error(&quot;desc=ExceptionProcessor.process error&quot;, e);
 }
 }


At this point, the coding is basically over , Then let's see how to pass maven Package the code we write into something that others can reference javaAgent

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-shade-plugin</artifactId>
 <version>3.0.0</version>
 <executions>
 <execution>
 <phase>package</phase>
 <goals>
 <goal>shade</goal>
 </goals>
 <configuration>
 <transformers>
 <transformer
 implementation=&quot;org.apache.maven.plugins.shade.resource.ManifestResourceTransformer&quot;>
 <manifestEntries>
 <!-- Modify the full path of your own class name -->
 <Premain-Class>com.****.AgentApplication</Premain-Class>
 <Can-Retransform-Classes>true</Can-Retransform-Classes>
 <Can-Redefine-Classes>true</Can-Redefine-Classes>
 </manifestEntries>
 </transformer>
 </transformers>
 </configuration>
 </execution>
 </executions>
 </plugin>


Use javaAgent

-javaagent:./lib/auto-monitor-alarm-1.0.0.jar


So far we have used ASM+javaAgent Realized try-catch Automatic monitoring of , Report , And for the code 0 invasion .

Take a look at the results achieved by our company

Four 、 summary

in summary , Used  

JavaAgent

  combination  

ASM

  Bytecode enhancement of monitoring method , You can catch the code that throws an exception in the method execution , And report the information to facilitate the R & D personnel to identify and pay attention to the error information , Improve the early warning mechanism of the project , Drive R & D personnel to actively find and deal with online problems , Improve code quality , Maintain the stability of the system , The task of R & D is not just code writing , But also for the code you write , Pay unusual attention , Effectively and proactively identify anomalies in operation , It is also part of our work ,

Turn to the technology learning and exchange platform of R & D center and industry partners , Regularly share front-line practical experience and cutting-edge technical topics in the industry . Official account 「 Transfer technology 」（ Comprehensive ）、「 Big turn FE」（ Focus on FE）、「 around QA」（ Focus on QA）, More dry goods practices , Welcome to share ~

Reference resources

https://www.infoq.cn/article/javaagent-illustrated

https://www.baeldung.com/java-asm​

Author's brief introduction

Guwenchang , Transfer to R & D Engineer of middle office payment center