SharePoint API
Several years ago, I wrote a SharePoint API in Java to interact with its List Soap Service. This soap service had a feature to query the target list using Collaborative Application Markup Language (CAML). Here’s an example of CAML query to filter the task list where the TaskName is “Foo Bar” and the Status is “In Progress”.

<query>
  <where>
    <and>
      <eq>
        <fieldref name="TaskName">
        <value type="Text">Foo Bar</value>
      </fieldref></eq>
      <eq>
        <fieldref name="Status">
        <value type="Text">In Progress</value>
      </fieldref></eq>
    </and>
   </where>
</query>

As part of this SharePoint API, I had written a corresponding set of Java classes – each node represented by a class. For trivial query like above, it would look like the following:

final Expression leftExpression = new Equals(new Field("TaskName", "Foo Bar"));
final Expression rightExpression = new Equals(new Field("Status", "In Progress"));
final Condition condition = new And(leftExpression, rightExpression);
final Where clause = new Where(condition);
final Query query = new Query(clause);

As you can predict, for complicated scenarios, this would quickly become unreadable. By applying the concept of Fluent Interface, we can make it far more readable. For example, the above become the following:

final Where clause =
  new Where(
    and(eq("TaskName", "Foo Bar"),
        eq("Status", "In Progress")));

Applying Fluent Interface
A good Fluent Interface takes a while to build. It should be built with the goal of readability and flow in mind. Return type should be chosen based on what you need to continue fluent action. Here’s the SharePoint API implementation. For the complete implementation, please see GitHub Source.

.
.
.
public static Condition and(Expression left, Expression right) {
  return new And(left, right);
}

public static Condition and(Expression left, Condition right) {
  return new And(left, right);
}

public static Condition and(Condition left, Expression right) {
  return new And(left, right);
}

public static Condition and(Condition left, Condition right) {
  return new And(left, right);
}
.
.
.
public static Expression eq(Field field) {
  return new Equals(field);
}

For complicated scenarios where you want to get all task assigned to John with status in “New” or “In Progress” and task created after Jan 1, 2014, the CAML would like the following.

<query>
  <where>
    <and>
      <eq>
        <fieldref name="AssignedTo">
        <value type="Text">John</value>
      </fieldref></eq>
      <and>
        <or>
          <eq>
            <fieldref name="Status">
            <value type="Text">New</value>
          </fieldref></eq>
          <eq>
            <fieldref name="Status">
            <value type="Text">In Progress</value>
          </fieldref></eq>
        </or>
        <gt>
          <fieldref name="CreateDate">
          <value type="DateTime">2014-01-01T00:00:00Z</value>
        </fieldref></gt>
    </and>
   </and></where>
</query>

Here’s the same in Fluent Interface

final Where clause =
  new Where(
    and(eq("AssignedTo", "John"),
    and(
      or(eq("Status", "New"),
         eq("Status", "In Progress")),
      gt("CreateDate", "2014-01-01T00:00:00Z"))));

Application Monitoring

There are several things to consider when monitoring an application. This is not meant as an exhaustive list but here are few items:

• application state
• resource utilization
• proactively report application errors
• module/component status
• external dependency status (databases, services, etc.)

The monitor should be proactive and not reactive. It should provide early enough warning before something goes wrong. This includes monitoring dependencies and the application itself. There are tools that monitor logs and report when it detects various errors in the log file. Although this is better than nothing, it’s too reactive. If you’re lucky enough to have nagios in-house, this is better. However, in most cases, they are configured only for Production and, if lucky, QA. However, for other environments, it may be an overkill to use nagios.

Health Monitoring

The purpose of my health monitor tool is to provide a simple framework to quickly setup and actively check the overall health of any application.

Health monitoring tool is built on the following open source frameworks:

• quartz-scheduler – used to schedule recurring checks to verify your site, components/modules, and dependencies
• apache httpcomponents – used to retrieve resources (JSON/HTML) from HTTP/HTTPS servers
• grizzly NIO framework – used as embedded web container to host status page (see above screenshot)
• jackson – used to parse JSON resources and configuration
• freemarker – used for web/email template
• javamail – used to send failure notification

It can proactively check your application and its dependencies with predefined service checks:

• com.jstrgames.monitor.svc.impl.HttpService – make non-SSL web call
• com.jstrgames.monitor.svc.impl.HttpsService – make SSL web call
• com.jstrgames.monitor.svc.impl.SimpleJmxService – make simple remote JMX calls
• com.jstrgames.monitor.svc.impl.SocketService – make a client socket call

It can then verify these services with predefined rules:

• com.jstrgames.monitor.rule.HttpResponseCode – check if expected status code returned
• com.jstrgames.monitor.rule.HttpResponseBody – check if body contains expected values
• com.jstrgames.monitor.rule.JsonResponse – check if specified JSON key has expected value
• com.jstrgames.monitor.rule.SimpleJmxResult – check if specified JMX attribute has expected value

All can be configured on a simple JSON format configuration file.

Example: Checking HTTPS site

The use case is to verify that the text “Google Search” and “I’m Feeling Lucky” appears on the google.com page every 5 minutes:

[{"servicename": "HTTPS Example (SSL)",
  "classname": "com.jstrgames.monitor.svc.impl.HttpsService",
  "schedule": "0 0/5 * * * ?",
  "hostname": "www.google.com",
  "port": 443,
  "uri": "/",
  "rules": [{
    "classname": "com.jstrgames.monitor.rule.HttpResponseCode",
    "condition": "equals",
    "expected": 200
  },{
    "classname": "com.jstrgames.monitor.rule.HttpResponseBody",
    "condition": "contains",
    "expected": "Google Search"
  },{
    "classname": "com.jstrgames.monitor.rule.HttpResponseBody",
    "condition": "contains",
    "expected": "I'm Feeling Lucky"
  }]
}]

Here, class com.jstrgames.monitor.svc.impl.HttpsService is used check www.google.com at port 443. Once the resource has been retrieved, 3 rules are executed:

• verify http response code is 200
• verify http response body contains the phrase “Google Search”
• verify http response body contains the phrase “I’m Feeling Lucky”

If any of the above checks fails, service is considered to be in “FAIL” status. If it fails to connect to said service, it is in “ERROR” status. It will also send out a notification and user will see a similar content in their inbox, granted, not as pretty.

For more details, please go to my github repository. I will be updating its wiki page soon.