Links

Metrics: library to measure behavior of critical components

Metrics is a Java library which gives you unparalleled insight into what your code does in production. Developed by Yammer to instrument their JVM-based backend services, Metrics provides a powerful toolkit of ways to measure the behavior of critical components in your production environment. With modules for common libraries like Guice, Jetty, Log4j, Apache HttpClient, Ehcache, Logback and reporting backends like Ganglia and Graphite, Metrics provides you with full-stack visibility.

Homepage:
http://metrics.codahale.com/

Getting started and Manual:
http://metrics.codahale.com/getting-started.html

Sourcecode:
https://github.com/codahale/metrics

Filed under  //   asl   java   jmx   library   metrics   monitoring   opensource  
Posted February 2, 2012 by email 

Jetty JMX Webservice

Jetty JMX Webservice is a webapp providing a RESTful API to query JMX mbeans and invoke mbean operations without the hassle that comes with RMI. No more arguments with your firewall admin, just a single http port.

That alone might not be a killer feature, but Jetty JMX Webservice also aggregates multiple mbeans having the same ObjectName in the same JVM (e.g. jmx beans for multiple webapps) as well as from multiple jetty instances. That way you’ve a single REST api aggregating JMX mbeans for one or more jetty instances you can use to feed your favourite monitoring system for example.

http://webtide.intalio.com/2011/05/jetty-jmx-webservice/

(download)

Filed under  //   java   jetty   jmx   mbean   monitoring   webapp  
Posted May 31, 2011 by email 

Metrics: Capturing JVM- and application-level metrics

Capturing JVM- and application-level metrics. So you know what's going on.

Metrics comes with five types of metrics:

* Gauges are instantaneous readings of values (e.g., a queue depth).
* Counters are 64-bit integers which can be incremented or decremented.
* Meters are increment-only counters which keep track of the rate of events. They provide mean rates, plus exponentially-weighted moving averages which use the same formula that the UNIX 1-, 5-, and 15-minute load averages use.
* Histograms capture distribution measurements about a metric: the count, maximum, minimum, mean, standard deviation, median, 75th percentile, 95th percentile, 98th percentile, 99th percentile, and 99.9th percentile of the recorded values. (They do so using a method called reservoir sampling which allows them to efficiently keep a small, statistically representative sample of all the measurements.)
* Timers record the duration as well as the rate of events. In addition to the rate information that meters provide, timers also provide the same metrics as histograms about the recorded durations. (The samples that timers keep in order to calculate percentiles and such are biased towards more recent data, since you probably care more about how your application is doing now as opposed to how it's done historically.)

Metrics also has support for health checks

Code:
https://github.com/codahale/metrics


Presentation:
http://codahale.com/codeconf-2011-04-09-metrics-metrics-everywhere.pdf

Filed under  //   java   jvm   metrics   monitoring   scala  
Posted April 11, 2011 by email 

Snorby: rails web application for network security monitoring

Snorby is a ruby on rails web application for network security monitoring that interfaces with current popular intrusion detection systems (Snort, Suricata and Sagan). The basic fundamental concepts behind Snorby are simplicity, organization and power. The project goal is to create a free, open source and highly competitive application for network monitoring for both private and enterprise use.

Image001

http://snorby.org/

https://github.com/snorby/snorby

Filed under  //   intrusiondetection   monitoring   opensource   rails   security   snorby   snort   ui   web  
Posted March 2, 2011 by email 

Hummingbird: Site tracking and analytics storage

Hummingbird lets you see how visitors are interacting with your website in real time.

And by “real time” we don’t mean it refreshes every 5 minutes—WebSockets enable Hummingbird to update 20 times per second.

Hummingbird is built on top of Node.js, a new javascript web toolkit that can handle large amounts of traffic and many concurrent users.

Hummingbird is organized into two parts: a node.js-based tracking server that records user activity via a tracking pixel, and a collection of javascript-based widgets that display that activity. The server records all activity in MongoDB and broadcasts it to the clients using WebSockets if possible, and falling back to Flash sockets if necessary.

The Hummingbird.WebSocket object receives websocket events from the server in the form of JSON objects. Individual widgets subscribe to a property in the JSON tree and register handler functions to be called whenever that property is present.

Image001

Project: http://projects.nuttnet.net/hummingbird/

Code: https://github.com/mnutt/hummingbird

Demo: http://demo.hummingbirdstats.com/

Filed under  //   javascript   metrics   mongodb   monitoring   node   realtime   web  
Posted February 24, 2011 by email 

Stashboard: open source status page for cloud services and APIs

Stashboard is a status dashboard for APIs and software services. It's similar to the Amazon AWS Status Page or the Google Apps Status Page. Stashboard was originally written by Twilio to provide status information on its Voice and SMS APIs. Stashboard is designed to provide a generic status dashboard for any hosted service or API. The code can be downloaded, customized, and run on any Google App Engine account.

  • Track multiple different API or SaaS services
  • Set custom status messages and icons such as Up/Down
  • Show historical status for each service
  • Runs on Google App Engine so it's independent of your infrastructure (unless your app is on GAE)
  • Full REST API for both getting and setting status information
  • CNAME to http://status.yourapp.com

Stashboard is written in Python and hosted on Google App Engine.

Image001

http://www.stashboard.org/

Filed under  //   monitoring   status   web   web service  
Posted December 16, 2010 by email 

Jolokia: remote JMX with JSON over HTTP

Jolokia is remote JMX with JSON over HTTP.
It is fast, simple, polyglot and has unique features. It's JMX on Capsaicin.

Jolokia is a JMX-HTTP bridge giving an alternative to JSR-160 connectors. It is an agent based approach with support for many platforms. In addition to basic JMX operations it enhances JMX remoting with unique features like bulk requests or fine grained security policies.

* Bulk-Requests
* JMX Proxy
* Secure
* Fast
* Simple
* Firewall friendly
* Polyglot

http://www.jolokia.org/features-nb.html

Filed under  //   agent   java   jmx   json   management   monitoring  
Posted October 21, 2010 by email 

Epsilon: Java library to simplify monitoring of Java application performance and latency

Epsilon is a Java library which is designed to simplify the monitoring of Java application performance and latency. It is designed to be no more intrusive than a common logger, but yet pack capabilities to draw inferences on application performance and issue notifications where said performance breaches pre-set criterion.
Why?

Application performance commands an ever increasing importance in today's enterprise environment. It is no longer uncommon for users to mandate performance or latency requirements for applications. Such requirements are sometimes driven by legally binding agreements between business entities, covering the provision of electronic services. At other times they are driven by the need to maintain a certain qaulity of service in relation to an organization's peers or marketplace.

Monitoring performance is no longer optional for a large number of IT departments and teams in today's world; particularly in the increasingly service oriented and losely federated world of electronic commerce and communication in which we now find ourselves.
What can it do for me?

The following are amongst the numerous features of the library:

Spring(tm)/Spring(tm) AOP support: It can be configured via the Spring framework, and can easily be embedded in Spring(tm) applications either via AOP or annotations.
Statistical inferencing: Application latency can be interpreted in the context of the applications historical performance, whilst ignoring outliers introduced by abnormal terminations.
Persistent state: By default, Epsilon persists historical task durations to a configurable location. This ensures that vital statistics are not lost on application failure, and can be interrogated by other applications (e.g. spreadsheets) to provide more colour on application performance. It is also possible to specify custom persistence managers e.g. to persist durations to a relational database, or in a custom format.
Highly performant and lightweight:It does not add any additional resource or latency pressure to monitored applications and has a highly negligible footprint.
Varied notification mechanism: Epsilon supports a very simple model for issuing notifications thus making it very easy for users to add custom notification handlers. For convenience, it is also shipped with a set of notification handlers, which reduces the need for the user to implement custom functionality.
Easy to extend:In line with the "keep it simple philosophy", Epsilon is intentionally made very simple to extend and customise. Although the chances of needing to do this should be quite remote for the non-power users.
Completely free and open source:We are passionate believers in innovation through openness and collaboration. Consequently, Epsilon, like all our other products is completely free to download and use.

http://www.obix-labs.com/display/jsp/technology/epsilon.jsp

User Guide:
http://www.obix-labs.com/wiki/bin/view/Epsilon/Epsilon1_0

Filed under  //   java   latency   monitoring   responsetime  
Posted October 7, 2010 by email 

API-Status: Uptime status of many public web APIs

http://api-status.com/

(download)

Filed under  //   monitoring   status   web  
Posted August 20, 2010 by email