BibSonomy ::  user :: gresch ::

New Relic is the only dashboard you need to keep an eye on application health and availability while monitoring real user experience. Complete visibility anytime you want it.

Kilim is a message-passing framework for Java that provides ultra-lightweight threads and facilities for fast, safe, zero-copy messaging between these threads. It consists of a bytecode postprocessor (a "weaver"), a run time library with buffered mailboxes (multi-producer, single consumer queues) and a user-level scheduler and a type system that puts certain constraints on pointer aliasing within messages to ensure interference-freedom between threads. Why? Hardware facilities are getting distributed, from the micro to the macro levels -- increasing numbers of cores, CPUs in a box, boxes in a data center to a multitude of data centers. The current crop of software architectures, languages and idioms are not suited to this trend. Here are a few reasons: A multi-core/CPU box is internally a distributed system, but operating systems and hardware manufacturers go to great lengths to provide an illusion of local shared memory. In reality, the illusion is never complete, which is why programmers have no option but to learn about non-trivial memory models and consistency schemes. The problems with shared memory has been well documented [ PDF ]. Different mindset between "concurrent programming" and "distributed programming". Programmers have to deal with both (even embedded systems have network interactions) and require separate sets of tools for verification, profiling and debugging these two patterns. The "events vs. threads" debate unnecessarily conflates two problems: threads are considered bad because they are (a) heavyweight (which doesn't have to be the case) and (b) the thread paradigm is implicitly associated with shared memory locking constructs that are error-prone, which again does not have to be the case. As Kilim demonstrates, it is possible to have lightweight threads that are just as lightweight as state machines, yet provide the automatic stack management feature (there's no need for the "return to the mainloop" mentality). The combination of lightweight threads plus message-passing is a good fit for the emerging world. It permits us to blur the line between concurrency and distribution -- the API (send/receive) is the same (although the failure modes and frequencies may be different), and allows a uniform set of tools for debugging, profiling, and verification. For example, the most common verification tool in practice, the SPIN model checker, is based on a message passing mindset. There is a good reason why Tony Hoare used "communicating sequential processes" as a model for verification.

UltraESB is the first [and still the only] Open Source Enterprise Service Bus (ESB) to utilize Zero-copy proxying with Memory Mapped files and Java Non-Blocking IO for extreme performance!

VisualVM is a visual tool integrating several commandline JDK tools and lightweight profiling capabilities. Designed for both production and development time use, it further enhances the capability of monitoring and performance analysis for the Java SE platform.

Beet records user behavior and performance data for your Spring-based Java application. It can thus help you to analyze usage patterns and research production performance issues. Beet requires Spring framework 2.0 and the Quartz Scheduler. Visit the Downloads page to grab a copy, and then read the Quick Start chapter of the User Guide to enable it in your application. Beet is freely available to use under the terms of the Mozilla Public License, v1.1. It was developed and is maintained by Mantis Technology Group, Inc. Features * Record Java method calls, SQL statements, and HTTP requests, or add your own events * Simple configuration, zero code modification required * Know immediately which user and session caused each event and when * JMX administration and diagnostic tools * Record data as XML, compressed binary XML, directly to an RDBMS, or write your own storage * Flexible ETL and log manipulation tools for compressed binary XML * Low resource overhead, appropriate for production systems

Usemon is a monitoring system for usage trends, response time and dependency analysis of plain Java applications or big multi-clustered Java Enterprise applications running in production. The proof of Usemon's stability and usefulness is confirmed by the fact that one of the worlds largest telecom operators is running Usemon in a clustered WebSphere environment with over 90 enterprise applications.

Elastica is a highly efficient and extensible, rules-based load-balancer for JBoss that adds dynamic behavior to EJB load balancing. Rules can be defined to redirect EJB requests according to request data, server performance data, or even the time of day

Jawr is a tunable packaging solution for Javascript and CSS which allows for rapid development of resources in separate module files. Developers can work with a large set of split javascript files in development mode, then Jawr bundles all together into one or several files in a configurable way. By using a tag library, Jawr allows you to use the same, unchanged pages for development and production. Jawr also minifies and compresses the files, resulting in reduced page load times.

Slow analyzes web pages and tells you why they're slow based on the rules for high performance web sites. YSlow is a Firefox add-on integrated with the popular Firebug web development tool. YSlow gives you: Download Now Install Firebug first! * Performance report card * HTTP/HTML summary * List of components in the page * Tools including JSLint

In spite of the example working, transaction management is not working appropriately when it comes to both Hibernate and JBossCache participating of the same transaction. The reason is because at the time of writing this wiki, Hibernate did not allow to inject a JTA Transaction Manager which is not bound to JNDI. In the example, Hibernate creates a JDBC transaction and JBossCache a JTA transaction which are not linked together. To be able to make a Hibernate and JBossCache participant of the same JTA transaction in a standalone environment, customer code needs to be added to Hibernate to get around the JNDI/JTA coupling.

JumboMem provides a low-effort solution to the problem of running memory-hungry programs on memory-starved computers. The JumboMem software gives programs access to memory spread across multiple computers, providing the illusion that all of the memory resides within a single computer. When a program exceeds the memory in one computer, it automatically spills over into the memory of the next computer.

The developer edition provides ALL of the capabilities of the server edition but limits console and terminal connectivity to the first 45 minutes of a managed JVM's processing. Snapshots taken before the expiration time can still be analyzed offline in the console and the console will reconnect to the JVM once it has been stopped and started.

(FromLinux Magazine Artiecle) Mstone is a multi-protocol stress and performance measurement tool. Mstone can test multiple protocols simultaneously and measures the performance of every transaction. The performance can be graphed throughout the duration of the test.

The Java Application Monitor (JAMon) is a free, simple, high performance, thread safe, Java API that allows developers to easily monitor production applications. * JAMon can be used to determine application performance bottlenecks, user/application intera

InfraRED is a tool for monitoring performance of a J2EE application and diagnosing performance problems. It collects metrics about various aspects of an application's performance and makes it available for quantitative analysis of the application.