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

Tag Archives: Insight

3 Steps on Using Spring Insight Developer to Analyze Code

If you don’t know about Spring Insight Developer, this post may save you tons of time and potentially headache.

Imagine that you need to update some code behind a button, but you didn’t write the code. What if you could press the to-be-coded button and then see what code was invoked (including methods and arguments), the SQL invoked, and the time it took to execute?

This is what Spring Insight Developer allows you to do, and more.

It’s also free, and it uses AspectJ and AOP to load-time weave your application, you do not have to make any changes to your application code to use it.

Let’s take a look at a simple example of tracing your app, viewing the details, and seeing the code in action.

Continue reading

Understanding the Difference between Spring Insight Developer & Insight Operations

Every developer knows Byte Code Instrumentation (BCI) is useful. It automates how you instrument your code, and let’s you see exactly how data is being transferred and manipulated within your application. The level of detail is essential to writing and debugging good code.

The Spring Framework has its own BCI tool, called Spring Insight. It comes in two flavors: Spring Insight Developer Edition (Insight) and Spring Insight Operations (Insight Operations). It is also bundled with AppInsight as part of the vFabric Application Performance Suite, and currently only works on Java/Spring code, a fact that is open to change with the upcoming Split-Agent Architecture.

So what is the difference?

Continue reading

vFabric @ SpringOne Next Week

The vFabric team is headed to SpringOne 2GX 2012 next week – from October 15-18 in Washington, DC. This is set to be a great event to learn the latest on Spring with over 100 sessions covering a wide variety of topics. For those of you looking to learn more about how vFabric is the best place to run Spring applications, here are the highlights you won’t want to miss:

1. Sessions:  There are a number of speakers from SpringSource, CloudFoundry, and the VMware vFabric team on the schedule, including:

Continue reading

JavaOne Architect Viewpoint: The Inexorable March toward Simplicity

Here is a quick field report from JavaOne!

We’ve talked to dozens of people, and the theme we keep hearing is simplicity, simplicity, simplicity.

Many amazingly bright application architects have stopped by to understand and learn more about the vFabric application architecture, and these folks hail from a number of industries – giant telecom manufacturers, government ministries of defense, and multi-industry service companies to name a few.


These conversations with architects have tended to fall into one of the falling categories: Continue reading

Spring Insight “split-agent” Architecture

Spring Insight is a technology that gives visibility into an application’s runtime performance and behavior. The original design called for the deployment of an agent application at each monitored server instance. Furthermore, the agent used only an in-memory mechanism to process the collected data that was assumed to originate from Java code. Recently, a “split-agent” mechanism has been implemented that allows the separation of the collection stage from the analysis one. In other words, the data is (still) collected by the same instrumentation plugins, but can be sent via various mechanisms to an analyzer application that performs the analysis and generates the same data as before – i.e., endpoints, metrics, external resources, etc. There are several advantages to such architecture – the most important ones being

  • Decreasing the impact on the monitored application by transferring the analysis functions to a separate process
  • Simplify installation and deployment of the Spring Insight framework by minimizing the number of required artifacts
  • Enabling other monitoring frameworks to use the Spring Insight analysis and display capabilities – including non-Java ones e.g., .NET, Ruby, PHP, Python, etc.

Continue reading

The Spring Insight RabbitMQ Plugin

Learn More


Spring Insight is currently bundled with SpringSource Tool Suite or vFabric tc Server.

Download STS
Download tc Server Developer Edition

RabbitMQ, vFabric’s message delivery bus, is widely used across n-tiered applications that require a reliable and fast queuing system. Message queues are a useful strategy in modern applications, helping to decouple application components so they can work asynchronously, while the message bus directs transactions between application components or external services. A new RabbitMQ client plugin for Spring Insight helps monitor your application’s behavior when communicating with RabbitMQ servers, and can help you analyze latencies and errors within your application that might not become immediately visible as no end-user interaction is made.

The RabbitMQ Plugin for Spring Insight allows for monitoring RabbitMQ Java client libraries at the code-level. Using this plugin you can monitor your application's performance around publishing and receiving messages through RabbitMQ.

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

Announcing the Spring Insight Bounty Program – A Pay for Development Marketplace

VMware is announcing a new Bounty Program which will enable companies, including VMware itself, to request and reward community members for creating any original work, including plugins, patches, tools, specifications, documentation, or sample code. The program is designed to leverage the Spring Insight community to support its own development needs for plugins that extend visibility into custom application's runtime performance and behavior.

Any company is welcome to make a public request (Bounty Request) to pay developers to complete project work around Spring Insight in the Spring Insight Bounty Forums. To start the program, VMware has requested 4 plugins to be developed by the community and will award up to $6000 for their successful development. Additional plugin requests are expected to be posted throughout the summer from VMware. Plugins currently requested include:

Continue reading

What’s New in EM4J 1.1?

Elastic Memory for Java (EM4J) 1.1 is a memory management toolkit for Java in vSphere, focused on enabling customers to confidently achieve greater memory efficiency for their Java workloads.

EM4J is a relatively new technology developed here at VMware which was created to solve the problem of memory reclamation in VMs predominantly running Java. This week, as part of the overall vFabric Suite 5.1 release, we introduced EM4J 1.1 which builds on that foundation with new monitoring capabilities in vCenter designed specifically to support Java workloads, as shown in this screenshot. First, however, if you are not familiar with EM4J, it may be helpful for a more detailed background on EM4J itself. If you are already familiar with it, you can skip to the section below on EM4J 1.1.


Using EM4J to Monitor JVM Heap Memory

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