Introduction to BTrace for Java applications

The aim of this article is to learn how to dynamically trace/observe running Java applications (JDK 6+) using BTrace without changing the code and configuration params of the applications.

What is BTrace?

BTrace is an open source project that was started in 2007 and was originally owned by two people – A.Sundararajan and K. Balasubramanian. It gained fame thanks to Java One 2008 conference.

BTrace helps us to pinpoint complicated code problems in the application. The problems that can be solved using BTrace include code bugs, unpredictable flows, concurrency problems and performance problems that happen under specific and usually hard to reproduce circumstances.

BTrace dynamically (without restarting application) instruments (changes) bytecode of an application in the way that programmer defines. The goal of the instrumentation is to see what happens in a specific area of the code. If used beyond this scope it may harm applications’ flow and therefore is forbidden by a validator.
For example let’s try to solve following problem – an important file gets deleted occasionally once a day. We want to find the code that does this. Therefore we would like to change ‘delete’ method of java.io.File and print a stack trace of the calling thread if the file name fits. With BTrace we can do this by writing a short and straightforward Java code.

The following schema displays principles of BTrace work.

In Target JVM there is a dynamically inserted BTrace agent (using attach API). BTrace client (either BTrace Command Line or Visual VM with BTrace plugin) sends commands to the agent and gets responses. BTrace agent instruments classes that are being loaded into Target JVM and reloads classes that have already been loaded.

Writing a Tracing script

Writing BTrace scripts is pretty simple and straightforward and has concepts similar to Aspect Oriented Programming concepts.

import com.sun.btrace.annotations.*;
import com.sun.btrace.BTraceUtils;

@BTrace
public class HelloWorld {

@OnMethod(clazz="java.io.File",method="")
public static void onNewFileCreated(String fileName) {
   BTraceUtils.println("New file is being created");
   BTraceUtils.println(fileName);
}

Each BTrace script consists of Probes (pointcuts in Aspects slang) and Actions (advices). A probe defines when the instrumentation should be executed. Action defines the instrumentation.
Probe can consist of the following:

  • Method entry/exit
  • Line number
  • Field updated/accessed
  • Method call/return (within specified method(s))
  • Exception throw (before)
  • Synchronization entry/exit
  • Timer
  • Constructor entry

Abilities and limitations of BTrace

Abilities

  • Dynamically connect to any java6 + application and run any(*) code

Limitations

  • Must run with the same user as the traced application is running with – due to security concerns
  • Supports Hotspot JVM only
  • Is compiled separately from the target application – is not familiar with application classes
  • May crush target application – I ran BTrace on our longevity setup which was heavily loaded with many Tracing scripts. Target application didn’t crush even once.

Advanced BTrace

BTrace community consists de facto of a single developer that works regularly on the project. Therefore don’t expect too much improvement and many new features in the next releases. (This is a good opportunity to contribute to the project as each developer will enhance the development significantly).

Documentation of the project should be significantly improved – I found myself guessing many times while integrating this framework into the existing frameworks at my job. BTrace forum is a good way to get answers about the framework.

In order to understand how the magic of BTrace works, knowledge in three fields is required – ‘Java Agents Development’, ‘Bytecode manipulation in java’ and ‘Java attach api’. I may write about some of these fields in the future.

Related linked

http://www.parleys.com/#st=5&id=1618&sl=1
http://kenai.com/projects/btrace

Reference: Introduction to BTrace from our JCG partner Art Gourevitch at the The Art of Java blog.

Related Whitepaper:

Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions

Get ready to program in a whole new way!

Functional Programming in Java will help you quickly get on top of the new, essential Java 8 language features and the functional style that will change and improve your code. This short, targeted book will help you make the paradigm shift from the old imperative way to a less error-prone, more elegant, and concise coding style that’s also a breeze to parallelize. You’ll explore the syntax and semantics of lambda expressions, method and constructor references, and functional interfaces. You’ll design and write applications better using the new standards in Java 8 and the JDK.

Get it Now!  

Leave a Reply


× 6 = fifty four



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use | Privacy Policy
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

20,709 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books