Home > Blogs > VMware vFabric Blog > Tag Archives: Spring Insight

Tag Archives: Spring Insight

New Pay for Dev Bounty Program for Hyperic & Cloud Applications Marketplace

With the launch of the VMware Cloud Applications Marketplace just two weeks ago, VMware is adding some extra incentives for developers to join our program. Several bounties ranging in reward values from $500 to $1500 are available for both Spring Insight and Hyperic.

Earlier this summer, VMware announced a bounty program for Spring Insight. Today, a similar Bounty Program for Hyperic is also available. The Spring Insight Bounty program has had 2 plugins currently committed, with one in the final acceptance quality assurance stage.

The Bounty Program is designed to complement the VMware Cloud Applications Marketplace, where completed and approved solutions are listed and ready-to-use. The Bounty Program, on the other hand, is a place where companies, including VMware itself, can request and reward community members for creating any original work, including plug-ins, patches, tools, specifications, documentation, or sample code. Customers and Open Source users of both Hyperic and Spring Insight are encouraged to list their own plugins in the forum. To list a bounty, you only need to be a member of the forums, which is free. Continue reading

vFabric Suite 5.2 Released

vFabric Suite 5.2 has been released and is now available for VMware customers to download and deploy. Considered a minor release, this update fulfills VMware’s desire to update the 13 different application components that comprise the suite every six months.  The improvements across the products for this version focus on improving standardization and consistency across products, an important maintenance effort as several of the products are relatively new to the vFabric product portfolio. Customers will universally benefit from standardization across products on five fronts:

  1. Platform Support
  2. Accessibility certification
  3. Globalization
  4. Packaging/RPMs
  5. Security Audits

Continue reading

Why Java Developers Need Spring Insight on CloudFoundry

Developers are realizing the benefits of using Platform-as-a-Service (PaaS) options, such as VMware’s own CloudFoundry.com, where they have choice of programming language, middleware options, and can start developing in seconds, without having to set up complicated infrastructure. While VMware runs the underlying infrastructure of CloudFoundry.com, application teams are still squarely on the hook to run and scale their applications.


Spring Insight answers the question “what just happened with my code?” and let’s developers see how code is behaving in development, stress test, or other environments for any Java application installed within their CloudFoundry.com account. 

Continue reading

Spring Insight Coming to WebLogic!

Always wished you could use Spring Insight but couldn’t because your applications run on Oracle WebLogic? Wish no more! 

Originally introduced for tc Server and since expanded to support Tomcat and JBoss , our next release will include full support for the WebLogic container. 

Combined with some specific WebLogic plugins that we have in our pipeline such as WebLogic Portal, WebLogic Tuxedo, and WebLogicMQ , Spring Insight will give WebLogic developers deep visibility into their application’s runtime performance and behavior. 

WebLogic support will include:

  • Versions 12.1 , 10.3 (a.k.a 11g)
  • Windows and Linux
  • Oracle HotSpot JDK, JRockit JDK and OpenJDK
  • Instrumentation of applications packaged as WARs and as EARs. This includes all class loader configuration options such as using shared JARs from the lib folder, using the prefer-web-inf option or the prefer-application-packages (configuring filtering class loaders) option.
  • Out-of-the-box installer to provide installation for the administration server of your WebLogic domain. A few simple steps will get it running on any other managed server you choose.

Continue reading

vFabric Usage and vFabric License Server

One change in vFabric Suite 5.1 is that the EULA now requires people to check their usage every 90 days. This is listed www.vfabric.co/eula – further below, there is an explanation on the simple way to get a report on this information:

At least once every ninety (90) days during the License Term (the ” Reporting Period”), You shall calculate, using all tools reasonably available to you, the average number of Virtual Machines in which You have run the Software during such Reporting Period (” Average Use”). If during any Reporting Period Your Average Use exceeds the number of licenses for which You have paid the applicable license fees, You shall: (i) report the excess use to VMware, within thirty (30) days of making the calculation, by providing written notice to vfabric@vmware.com; and (ii) pay to VMware, within thirty (30) days of the date of VMware’s invoice, the license fees due for such additional licenses. The day following an Average Use calculation shall begin a new Reporting Period.

The vFabric License Server makes it easy to get a quick view of license and product usage over time. The simplest way to find overall usage is to visit the web report interface. Simply enter the URL in a browser: https://host:8443/vfabric-license-server/report/create where host is the address of the computer in which you installed the vFabric License Server. You’ll see this page in your browser:


Continue reading

Using AspectJ for Accessing Private Members without Reflection

During development of Insight plugins we sometimes come across the need to access a private member of some 3rd party library.

The common approach for this is to use reflection:

While this is a widely accepted and simple approach, we searched for a way to improve this, mainly due to performance concerns as we try to maintain a very low overhead for our code agent.

Following is an alternative way we came up with for doing this with AspectJ.

The main idea is to use a mixin aspect (using inter-type declarations) that introduces a getter for the private member to the accessed class.
Then an around advice can be written to intercept calls to this getter method, in which the private member is returned and no call to proceed() is made.
This is similar to the useful idioms described in AspectJ in Action, Second Edition (Section 5)  for providing a default interface implementation or for introducing members to multiple types, with the addition of the around advice that "hijacks" calls to the new getter.

It is important to note here that while it seems that we have declared an interface that any class can implement, the implementing aspect relies on the actual instrumented object being of the concrete SomeClass type.
This means that SomeClass must be visible to your code (public). Otherwise refelction is still the only option.
The aspect is declared as privileged in order to enable the access of the private member of the target object once it has been cast into the concrete SomeClass  type.

Here are the classes in play:

  • The class with the private member
  • The interface declaring the public getter
  • The privileged aspect, containing the mixin declaration of the interface and the around advice
  • Example of accessing private member from a different class

Two things should be noted when using load-time weaving:

  • Since AspectJ will only weave during load time, the interface should be declared in a separate java class. This is necessary in order for the java compiler to recognize these calls from other classes : ((PrivateMessageExposer)privateClass).getPrivateMessage();
  • In order to protect your code from API changes in 3rd party libraries, you should  catch NoSuchMethodError exceptions that will be thrown during runtime.

Following is a summary of some basic performance tests we ran, where we compare execution times of a loop that is executed n times with reflection/weaving. The loop simply accesses the privateMessage field of the same instance n times consecutively.
The tests were run with the following hardware – 8 Cores x Intel Xeon E5410 @ 2.33 GHz. 16 GB memory (Heap 1GB).
As the table shows, the performance gain reaches 31% as the number of execution times gets higher, but there seems to be some performance degradation for lower numbers.


Depending on your needs and existing use of AspectJ, this could be a simple way to gain a performance improvement. In order to know if this will indeed result in a performance improvement and of what magnitude, you should run your own performance tests, since the results above are not conclusive, and moreover, represent a very simlified use case.

In addition to the possible performance gain, you gain more type safety than with reflection, as can be seen by this line of code : return ((SomeClass )obj).privateMessage;

  – Talya Gendler, Spring Insight Engineering