A DESCRIPTION OF THE REQUEST :
We would like to see the JVM technology for dynamic bytecode instrumentation productized in some future JDK version, preferably JDK 1.5. Such a technology is available in the JFluid experimental project by Sun Labs (see http://research.sun.com/projects/jfluid). It enables tools to dynamically instrument and de-instrument bytecodes of running Java applications, usually in order to obtain performance information. However, we understand that the same functionality can also be used for other purposes, e.g. code coverage, fault injection, or even patching bugs without stopping a program.

We also understand that the JFluid JVM provides a mechanism that keeps the above
instrumentation capability "always on". That is, it enables tools to attach to, and instrument, any program, even one running in a production mode, without any special JVM settings. Such an option, though probably it should be considered separately, is also very desirable to have.


JUSTIFICATION :
JFluid or technology similar allows for applications to be dynamically instrumented with diagnostics, monitoring, and other management features that improve the manageability of J2SE and J2EE applications and servers.
(Review ID: 185678) 
======================================================================

N/A

The bug fixes and performance work needed so that the NetBeans Profiler (JFluid) can run well with the JDK have been integrated into mustang (6.0) and also 5.0 update 4. See 5109602, 5079751, 6200138, and 6203233.
  xxxxx@xxxxx   2005-03-21 09:35:08 GMT


It's now time to close this bug! All the bug fixes and performance work to make the NetBeans Profiler (JFluid) work really well with JDK5.0 and mustang (6.0) is complete. The changes are in mustang since b26 (download the latest mustang snapshot from https://mustang.dev.java.net/). For JDK5.0 the changes have been back-ported to 5.0u4 - sorry it's not 5.0u3 but the changes are too extensive and 5.0u3 was too far along to integrate them late in the schedule. 

The other news is that milestone 6 of the NetBeans Profiler has been released. (download it from http://profiler.netbeans.org/). In milestone 6 the profiling agent has been ported to JVMTI (the new tools interface added in JDK1.5 via JSR-163).  

  xxxxx@xxxxx   2005-04-20 08:14:22 GMT

In addition to replacing method implementations, it would be nice if 
this could add new fields, methods and interfaces to an existing 
class.

I would like on the same topic to have a ClassPreProcessor 
hook in the java.lang.ClassLoader as BEA provides it for its 
custom classloader since a while. This is usefull to enable on 
the fly instrumentation thru bytecode modification.

Explanation:
java -Dpreprocessor=impl.MyPreProcessor
Sun bundles a java.lang.ClassPreProcessor interface:
  public void init(); // called once per JVM per PreProcessor imp
  public byte[] weave(String klassFQN, byte[] initial, 
ClassLoader caller);
Sun bundles an enhanced java.lang.ClassLoader which calls 
the PreProcessor impl just before all calls to native defineClass
(..).
[ note: all of this is implemented since 0.8 release in 
AspectWerkz - see 
http://cvs.codehaus.org/viewcvs.cgi/aspectwerkz/src/main/or
g/codehaus/aspectwerkz/hook/?root=aspectwerkz ]

There are several arguments:
- BEA ships this sort of mechanism since a while. It is not JVM 
wide but tight to the custom classloader deploying war / ejbs, 
so it is a bit limited
- having such a thing is a huge progress and enabler for AOP 
solutions like AspectWerkz and AspectJ and others
- having such a thing in java 1.5 could ease to plug a 
weaving engine of an AOP framework. With AspectWerkz it is 
possible to do it thru several options, mainly based on 
replacing the java.lang.ClassLoader with the enhanced one 
(thru HotSwap or as educational purpose thru -
Xbootclasspath [ forbiden by Sun license ])
- this features is already implemented thru JVMPI 
CLASS_LOAD_HOOK event, and there is a need to have it at 
the java level (mainly to have the callerClassLoader 
information which is laking in JVMPI event).
- this feature could also be used to provide pure java 
instrumentation solutions / profiling thru bytecode 
modification.
- There are other projects like JMangler, who needs this kind 
of feature and have implemented it thru HotSwap for now.
- This feature is not another HotSwap. It is used at 
deployment time (class loading time). Not at runtime.
- This feature does not engages a big overhead when turned 
off.
- The java 1.4 System classloader replacement option thru -
Djava.system.class.loader is a step forward, but is not 
enough since it does not allow to intercept class loading by 
custom classloaders used in J2EE.

If you need further information, please drop me an email - 
alex@gnilux.com

jfluid provides very important functionality not available
(forJava) elsewhere.  It is also very nice, well designed
software.  I would very much like to see it productized.

Really cool stuff, Would love to see this in future Java version.

Jfluid has helped us tremendously where other tools such as 
optimizeit and jProbe hasn't been able to. Therefore this is a 
vital tool in Java development. PLease make this tool priority.

Rue de Silva
rdesilva@daleen.com

An interesting tool with features not in JProfiler, JProbe or 
OptimizeIt. I am working with JFluid and will see for 
integration with my web applications later, thanks Mikhail.

Regards,
Ravi

would be great to see dynamic bytecode instrumentation
capability producitzed in the JDK

+1

+1

JFluid is very nice and must be included in the next JVM

paul.perez@pymma.com

I really wish to see JFluid in J2SE.

yes please.

Would love to see this in 1.5. So vote +1 from me.

James

great :)
+1

Hi Misha,

I had meen working on JFluid since October. Please 
accept my vote, this is so great. Why dont you bundle it 
with J2SE 1.5 ?? Thanks a lot

No doubt JFuid is perfect tool. Great work done. 
Can it be bundled with JDK future releases? If so, it is 
going to be one more milestone for SUN and no one 
else can reach. 
Keep up good work Misha. 

This feature should no doubt be included in a future 
JVM, and JVM 1.5 if possible.  It will greatly increase 
the atraction of Java technology.

Yan

It would definitely be a great thing to put in the standard
JVM. Being able to gather data without requiring some
special test environment is wonderful.

+1

+1

Great program!

+ 1

Very interesting idea!
We would love to have it for injecting faults and 
measure results in java application.

+1

I've just used JFluid - it's great!. This should be part of
a standard release.

Please do this as soon as possible, if possible.

java goes strong AOP. booh. that is enough to migrate 
10 millions of VB geeks :-).

Enabling the things required by Jfluid, adding what 
Crazybob previously said and introducing the 
Multitasking VM would make Java the f*king coolest 
platform ever existed. And ofc a java desktop that 
would run at least as fast as windows (which could be 
almost possible with MVM I suppose)

JFluid is extremely valuable for debugging in the field.
Having it in the standard JVM would be a big win.

I really like JFluid! Lets put it in the next JDK!!!!!

This feature is now in a must have category and by the way,
other vendors are about to have it quite soon. For exampl
JRockit team is working close woth AspectWerkz guys to
provide a proprietory API for fast bytecode instrumentation
in the runtime.

HI This is very intresting. and hope can release full product soon ( for Client Server ) 
Polimetla VK

this would be a great addition.

I found JFluid is a great tool. So I add +1 vote.

I have used JFluid and can say that it is the ONLY technology for profiling that is non-intrusive enough to be usable for our application.  I strongly recommend sun get these enhancements in the release VMs (1.4 and 1.5) at the very least as a -XX option.

Would love to see this technology incorporated into JDK GA release as soon as possible .

Thank you

+1

Many thanks to everybody who voted for JFluid!

I hope you will be pleased to know that JFluid is now out of the Lab and is being productized, initially as a NetBeans integrated profiler (check http://profiler.netbeans.org). Early access 1.0 "milestone" releases happen approximately every month and are available for download right now (so far they use the customized JVM based on JDK 1.4.2). The final JFluid/NetBeans Profiler 1.0 release is planned as a part of NetBeans 4.1 due in Spring 2005.

Misha Dmitriev,
former Sun Labs JFluid Project lead,
now at NetBeans

+1 it would be very nice to see it added as a standard JVM feature 

hope it can work with standard JVM ASAP.
Thanks!

Wish to see JFluid features as part of the Standard JVM very soon. 
+1

Would look forward to see the JFluid features as part of the J2SE very soon

J2SE update 4?! how about update 3? ^^

Simply Exceptional