iFountain.com blogs

RapidOSS is available on all mobile phones

berkay — Mon, 09 Nov 2009 10:03:57 -0800

Couple of weeks ago, we had announced that RapidOSS UI for mobile devices (Mobile IT management comes to town) and presented how RapidOSS mobile support enables users to work with management tools like Netcool and EMC/Smarts from their mobile devices.
Initial support was restricted to iPhone and Android devices. Today I'm happy to announce that RapidOSS web UI works as a read/write user interface on all mobile devices, including Blackberry devices.

We've stripped down some of the fancy javascript and CSS from the UI to enable it work on a much larger set of mobile devices. There may still be incompatibilities with some mobile browsers but based on our tests it works with most current mobile devices.

As I mentioned in the previous post, we've chosen to develop for the web browsers rather than native apps for iPhone and other platforms. This decision has so far paid off as we were able to add support quickly for new platforms (Android, Blackberry, etc.) as well as other mobile devices that have a web browser rather quickly.

Mobile revolution is here. We will continue to push forward in this area towards our objective of making mobile IT management a reality.

If you'd like to try the interface from your mobile, point your browser to the demo on our web site and login with username mobileuser password mobileuser. If you have an iPhone or an Android phone, you can still use the more fancy interface

As always, I'd love to get your feedback. What should we work on next?

RapidInsight is now RapidOSS

berkay — Thu, 01 Oct 2009 04:13:37 -0700

Careful eyes may have noticed that RapidInsight product has disappeared from our website! Need not worry, it's still alive and kicking :) RapidInsight has just gone through a name change and has become RapidOSS.

We've found out that "Rapid Insight" is a registered trademark of Rapid Insight Inc, and we were asked not to use this name as our product name. That'll teach me to be more careful with trademark searches. Four years ago when we selected this name I had not found this trademark. My guess is that I had not thought of searching it as separate words at the time, and Google did not have much to say either. A useful tip: if you're doing trademark searchs, a new website called Trademarkia is pretty useful.

It'll be tough for us to let go of RapidInsight mentally since we have been using it for quite sometime but we'll manage. King is dead, hail the new king. Please welcome RapidOSS to your IT management arsenal :)

iPhone comes to Netcool

berkay — Wed, 23 Sep 2009 08:13:04 -0700

In the previous post, I had discussed why and how we had build a web based UI specifically for iPhone and hinted that this means Netcool users now can work with Netcool from their iPhones. In this post, I'll go further into what this means and how it works.

- RapidInsight is already integrated with Netcool:

RapidInsight Netcool plugin retrieves events and journals from Netcool, and indexes/stores in RI repository.
Everything in RI repository is instantly searchable hence users can perform google like searches to find the information they need.
Users can view the events through RapidInsight UI (best web based event management console in town bar none, in my not so humble opinion :)
Users can take action to manage the events (acknowledge, suppress, escalate, assign ownership, etc.)

- With the iPhone support, users can now do event management directly from their iPhone. RapidInsight detects iPhone safari web browser and serves the iPhone specific UI to the users. The UI is designed to work like native iPhone application and enables users to browse the events, use pre-saved queries or perform ad-hoc queries, and take relevant action

- RapidInsight iPhone UI goes beyond providing an iPhone UI for Netcool. RapidInsight integration capabilities enable users to also access other relevant management information such as inventory/configuration data on devices, performance trending graphs etc. directly from the same UI. Just picture that users being able to use their iPhone throughout the IT processes without having to go back to their desktops, and without having to jump from tool to tool to do their jobs!

RapidInsight v3.7 has just been released and includes the iPhone support. Download it here and take it for a spin. If you would like to take a look at a sample implementation, visit the demo our website with your iPhone. And as always, let us know what you think. Looking forward to hearing your thoughts

...

Mobile IT management comes to town

berkay — Wed, 16 Sep 2009 12:38:46 -0700

Some observations:

One of our key objectives has been to provide a unified, web based user interface for IT operations. We believe users should be able to navigate through management information seamlessly rather than being forced to jump between disparate tools and inconsistent user interfaces.
Users are no longer content being forced to watch a specific console (or worse multiple consoles!) on a computer screen and should be empowered to control how (IM clients, email, SMS, etc.) and when they receive the information, and act on the information as necessary.
After many years of anticipation, mobile revolution is here. iPhone is a viable computing device for many business applications, and there are 10s of millions of them (iPhone and iPod Touches) out there.

Conclusion:
We need to ensure users can work with management information from their iPhones (and other mobile devices) to be able to do their jobs effectively. So how should we do this?
As it is on the desktops, we have the option to develop a native application for iPhone or a web application since iPhone has a solid web browser. Some pros and cons for a native iPhone application:

Pro: A native iPhone application has many advantages as it can leverage native device capabilities such as push notifications.
Con: There are already different iPhone models and OS versions out there, and differences will likely increase in the future.
Pro: Installation of the applications is much easier than desktops through Apple's App Store.
Con: Although an application can be installed easily on an iPhone by the users, it seems to be extremely difficult to get an application (and updates/fixes to applications) into Apple App Store and then to users. It is simply not acceptable to wait weeks or months for Apple's approval to roll out bug fixes to an application in the enterprise environment.
Con: A native iPhone app requires learning a new programming language and a platform, where developing a web application for iPhone is just requires minor adjustments. This new development, combined with obstacles on deploying an application to an iPhone, makes it infeasible to make enhancements to the application in the field, which is a show stopper for us.

As can be inferred from the analysis above, we've concluded that a native iPhone app is not suitable for our requirements (as I suspect for many enterprise apps) and decided to develop a web application instead.

Technically, RapidOSS UI is already a web application, so once the various browser compatibility issues are resolved, it can be used as is. However, iPhone is a mobile device with a very different form factor than a PC, hence usability of the application can be increased drastically if we take the differences into account when designing the user interface.

So our objective is to extend the RapidOSS's promise into iPhone and other mobile devices, by enabling users to work with their IT management applications from a unified, consistent, web based UI that takes advantage of the unique capabilities and differences of iPhone.

The first version of the RapidOSS iPhone plugin targets events management. Using the same powerful search engine and saved query mechanism, Users can navigate through events, and take actions to acknowledge events, take ownership, change severity, etc.

If you'd like to give it a try, point your browser to the demo on our website. RapidOSS will detect an iPhone and serve you the right user interface. If you'd like to try this at your own environment, watch this space. The next release of RapidOSS (scheduled for Monday) will include iPhone support. Any feedback and suggestions are more than welcome!

Since RapidOSS already has integration with EMC/Smarts, IBM Netcool, etc. this means you can now use your iPhone to work with these systems, search and browse events, and take actions right from your iPhone. In the next post, I'll go through how you can use RapidOSS iPhone support and Netcool plugin to implement iPhone UI for Netcool. Stay tuned!

Topology Maps in Network Management

berkay — Wed, 26 Aug 2009 06:02:38 -0700

Topology maps and events lists (aka alerts/alarms/notifications) are two most commonly used UI patterns to present monitoring data to users in network monitoring. The usefulness of topology maps is not an agreed upon subject in the network monitoring community. Some folks think maps are "must have" for a monitoring tool, others don't care for them at all.

Most monitoring tools in the market do offer some kind of maps functionality, but the quality varies significantly, not all maps are created equal. I think usefulness of the network topology maps highly depend on the design of the solution. Network monitoring field is full of people scarred by the experience of manually maintaining the hierarchical maps (a la HPOV NNM). I personally think maps indeed can be useful when implemented right, and many people do request it hence we've added Maps to RapidOSS.
Distilling the experiences of the past, we've steered clear of the most common pain points associated with maps. Here is how/why RapidOSS map component is different:

- Flash (flex) based

RapidOSS has a web based UI. We try to use the browser natively (html/javascript) as much as possible. However, we have not found a robust library to be able to create maps in the browser natively and work in all major browsers (I'm looking at you IE).

We believe that the user experience with a flash based component is a lot less problematic than the alternatives (java applets, SVG plugins, Canvas emulators etc.) and over 90% of PCs already have flash installed. Hence, we've developed RI map component as a flash component, using flex and the excellent Flare library.

- Automatic or manual layouts

Users still manually organize the position of the icons and save the layout, however RI maps can also use layout algorithms (circular, hierarchical, etc.) to determine the position of each node, hence manual positioning of the nodes in the map is not required.

- Focused maps

RI maps can focus on a specific area of the network topology and expand as necessary. A typical scenario is to launch the map from the event list to see the related device and the devices that are one hop away. This approach is essential in making browsing through large networks manageable.

- Integrated

RI UI components can communicate with other and exchange data which makes As with other RI UI components, map component can be used as part of a page, can exchange data (communicate) with other RI (javascript) components, etc., which enables dynamic, interactive user interfaces. In addition, actions can be executed from the drop down menu, integrating the menu with other tools and UI components to provide additional relevant information to users.

- Decoupled component

Like other RI UI components, map component receives data from RI server as standard XML, hence the client side Map component is decoupled from the origin of the data. This means the component can easily be embeded into other management solutions as long as the solution can serve the data as XML to the client.

Many monitoring tools have the maps tied to their server. This means therefore if the tool cannot discover devices or the connections among them, there isn't an easy way augment the data. RI server side scripts can retrieve the data from RI repository, other data sources or a combination of them. For example, for an event from Netcool about a device, topology data can be retrieved from an in house database (element manager, provisioning system, etc) and the device, connected devices as well as related applications etc. can be displayed on the map.

- Customizable

The information presented by the nodes in in RI can be customized. In addition to the drop down menu, the nodes can include 3 icons at the corners and the icons can change depending on the properties of the node objects to present status of the node, role of the node etc. There is also a gauge icon that can be used values such as utilization, etc. dynamically. And since the source code is open, more unique requirements can always be added to the code.

- Multiple layers

RI Map component can be used present multiple layers from physical layer to service dependencies, hence can be used to present cross domain connections, etc. and not just the IP networks.

Here is a short screencast that shows the map component as part of RapidOSS. Live demo on our site also includes the map component if you'd like to play around. As always, any feedback would be much appreciated. What is missing, what would you like to see?

iFountain’s RapidOSS Received 2008 EMC Partner Solution Award: Offering of the Year for EMC Smarts

berkay — Wed, 13 May 2009 06:33:07 -0700

FOR IMMEDIATE RELEASE

Press Release - May 13, 2009

iFountain, an innovative independent software vendor specializing in IT Operations Management announced that its RapidOSS product is the winner of the EMC® Velocity² Technology & ISV Program “2008 EMC Partner Solution Award: Offering of the Year for EMC Smarts®.”

The award recognizes iFountain's RapidOSS for its market presence, business impact, leads generated, commitment to and leverage of EMC technology, and revenue contribution among EMC Smarts partner offerings in the EMC Partner Solution Gallery.

“We're honored to receive the EMC Partner Solution Award for our RapidOSS solution and we look forward to continue work closely with EMC to help our mutual customers manage their IT infrastructure more effectively” said Berkay Mollamustafaoglu, CEO of iFountain.

iFountain's RapidOSS application provides integration, automation and presentation capabilities seamlessly integrated with Smarts, and can be viewed on the EMC Partner Solution Gallery. The combined solution maximizes the return on investment provided for joint customers.

“EMC is pleased to offer an extensive selection of solutions built by our development partners, across EMC platforms, in the EMC Partner Solution Gallery. We congratulate iFountain for winning the 2008 EMC Partner Solution Award: Offering of the Year for EMC Smarts,” said Shahram Moradpour, Director
of Partner Development at EMC.

About iFountain Software

iFountain is dedicated to providing IT Operations Management solutions for organizations that rely on their technology infrastructure as a strategic asset, and enabling businesses to maximize the return on investment made on IT management solutions.

iFountain solutions dramatically simplify the process of integration between disparate management systems and data sources, empowering IT organizations to align management systems with the business services they support.

For more information visit www.ifountain.com

Don't call me I'll call you. Heartbeat Monitoring Demystified

berkay — Thu, 07 May 2009 06:54:34 -0700

“Polling” and “listening” are the most common monitoring techniques. Polling is where monitoring systems periodically call monitored systems to check whether the systems is operating as it should, and collect data (performance, etc.). Listening is where monitoring system waits (listens) for monitored systems to either directly or indirectly (through other systems, etc.) send information. In network monitoring, monitoring system polling SNMP agent of the devices, etc. is an example of polling technique, and processing of traps and syslog messages are examples of the listening technique.

Heartbeat monitoring is another technique that can be considered an enhanced form of listening. Some systems periodically send information,(events) aka heartbeats, to signal that the system is operating as it should. In this case, the absence of these heartbeat events and not events themselves indicate a problem, hence these events need to be processed differently than typical events.

It's always been possible to implement the necessary logic to handle heartbeat events in RapidOSS. With the version 3.3, RapidOSS now includes a reference implementation to process heartbeat events.

Instead of creating an event for each heartbeat and then processing/correlating these events, heartbeats are stored in a separate class. RsHeartBeat class provides all the functionality required to process and store heartbeat messages. Process is straight forward:

1. Identify the objects that should receive periodic heartbeats with name and the expected frequency of the heartbeats.
RsHeartBeat.configureHeartBeatMonitoring(“System1",60)

2. Process received heartbeat events
RsHeartBeat.recordHeartBeat("System1")

3. If a heartbeat is not received for a monitored system longer than the specified heartbeat interval, an event is created.

4. Event is cleared automatically when a heartbeat is received again.

There are number of use cases where heartbeat monitoring approach can be very useful. When using listening approach to receive events from external systems, a heartbeat can ensure the sending system is operational (no news is not necessarily good news!). In fact, we often use this technique to monitor the monitoring systems themselves. For example to ensure that SNMP traps are processed throughout out the system a trap may be sent periodically as heartbeat. Absence of this trap for longer than specified period would indicate a problem somewhere in the chain and has to be address immediately.

I believe that the functionality included as part of RapidOSS v3.3 will reduce the barriers to using this technique and make it easy to implement heartbeat monitoring.

Managing Planned and Unplanned Maintenance with RapidOSS

berkay — Tue, 05 May 2009 01:47:58 -0700

Handling of the planned/unplanned maintenance of IT infrastructure is an essential event management activity, yet it seems to be an after thought in most tools. The accuracy of the information presented to users is essential. Users need to know what it truly a problem that requires immediate action and what is not.

Where IT organizations hold maintenance information varies widely from excel spreadsheets to service desk software, which is one reason why handling of maintenance in event management is often a field activity. Nonetheless, event management systems can provide the infrastructure to facilitate the implementation of planned/unplanned maintenance of IT infrastructure components. RapidOSS had inherent support for enrichment and processing of events using data from external sources, and it's always been possible to implement maintenance management. With the release of version 3.3, RapidOSS now includes a reference implementation that can be used as is or modified easily to meet specific requirements in the field.

In line with the general philosophy of RapidOSS, maintenance management functionality is implemented as operations (methods) of a class, hence fully programmable, can be automated. Using integration capabilities of RapidOSS, maintenance information can be retrieved from other systems, database, spreadsheets, etc.

In addition to the programmatic methods provided to facilitate integration and automation of the maintenance process, user interface components (that use the same underlying operations) are provided to manage maintenance state of objects interactively through the RapidOSS UI. Users can launch maintenance view from events, etc. and change maintenance status of objects or schedule maintenance periods for future.

Functionality covers most common scenarios:

An object (a device, link, interface, application, etc.) can be put into maintenance mode or taken out of maintenance mode (programmatically or interactive via the UI)
User can specify a fixed amount of time as the duration of the maintenance period. At the end of the specified duration, object would be taken out of maintenance model
Maintenance period can be scheduled for future date and time
When an object is put into maintenance mode explicitly (via the UI or by an integration script etc.), or due to a scheduled maintenance window, related events are also flagged. Similarly, when an object is taken out of maintenance mode, flag is removed from related events.
When new events are processed, the maintenance status of the relevant object is checked, if the object is in maintenance mode, the event is also flagged.
When a scheduled maintenance ends, maintenance flag is removed from the object and the related events.
Users can filter our events related to objects in maintenance, use saved queries to see only maintenance events, etc.

And since RapidOSS can already process event streams from Netcool, EMC Smarts, OpenNMS, etc., maintenance functionality can be used to manage maintenance in these systems as well.

Maintenance module files are provided as part of RapidOSS include in the solutions directory. Further information can be found in the integrators' guide.

RapidOSS wins EMC Smarts 2008 Offering of the Year Award

berkay — Thu, 16 Apr 2009 11:56:01 -0700

Stop the presses! We've been notified by EMC Smarts that our RapidOSS product has been awarded “2008 Offering of the Year Award”

As you can imagine we're thrilled about this! iFountain has been an EMC development partner for several years now and we have developed number of solutions that complement the EMC Smarts production suite. It is very nice to get some recognition and appreciated by everyone in the company.

Simple consistent interfaces to external systems

berkay — Thu, 02 Apr 2009 06:52:06 -0700

In my conversations with potential customers and in documentation, I often state that RapidOSS makes it easy to work with external systems. Since "easy" is a relative concept, without some concrete examples this may not mean much to folks who don't have first hand experience working with RapidOSS.

Integration with external systems very often require in-depth understanding of the APIs provided by the external systems. Even when the external system provides standard APIs (SOAP, database etc.) it is not easy to master the variations from the standards, and figure out the structure of the data, how to use it.

In RapidOSS, we use a simple data structure consistently for all external systems. If the data is a single object (record, line, etc.) it is represented as name value pairs, referred to as “Map”. For example, if we want to represent employee information, we could use the following structure:



def employee = [name:”John Doe”, department:”Accounting”, age:34]
// We  can also use the following alternative format with the dot notation to the same end:

def employee = [:]  // initializes a Map

employee.name = “John Doe”

employee.department = “Accounting”

employee.age = 34

To represent multiple objects, we use “List of Maps”. For example to represent employees:



def employees = [

    [name:”John Doe”, department:”Accounting”, age:34],

    [name:”Jane Smith”, department:”Finance”, age:25]

]

These are easy data structures to work with and groovy provides number of powerful yet simple methods to work with these List and Map data structures.



println employees[0].name // prints “John Doe”

println  employees.name // prints [“John Doe”, “Jane Smith”]

employees.each { employee -> //iterates through the list

    println employee.name

}

So when we create integration layers with external systems, we map the data structures provided by the external systems into these simple and flexible data structures available in Groovy.

To demonstrate how this works in practice, let's say we'd like to create an event in various systems. Let's start with RapidOSS itself. How to create an event in RapidOSS? The mechanism is simple, put the event properties into a map and call an operation (method of a class) to create the event in RapidOSS repository.


def eventProps = [:] //intialize a Map

eventProps.name = “MyTestEvent”

eventProps.severity = 3

eventProps.elementName = “LabDevice1”

eventProps.source = “test script”

eventProps.description = “creating an event for testing”

RsRiEvent.add(eventProps)
// or similarly in a single line by defining the structure directly inside the operation.

RsRiEvent.add(name:“MyTestEvent”, severity:3, elementName:”LabDevice1”, source:”test script”)

How would you create an event in Netcool? The mechanism is the same, the only difference is that the names of the event properties (fields as they are referred to in Netcool) and the class operation


def eventProps = [:]

eventProps.identifier = “MyTestEvent”

eventProps.severity = 3

eventProps.node = “LabDevice1”

eventProps.summary = “creating an event for testing”

// we need to specify which external system we want to work with def netcool = NetcoolDatasource.get(name:“Omnibus”) netcool.addEvent(eventProps)

How about EMC/Smarts?


def eventProps = [:]

eventProps.eventName = “MyTestEvent”

eventProps.severity = 3

eventProps.instanceName = “LabDevice1”

eventProps.className = “Test”

eventProps.sourceDomainName = “RapidOSS”

eventProps.eventText = “creating an event for testing”

def smarts = SmartsNotificationDatasource.get(name:“SAM”) smarts.addNotification(eventProps)

And OpenNMS?


def eventProps = [:] 

eventProps.uei =   “MyTestEvent”

eventProps.node =  “LabDevice1”

eventProps.source =  “RapidOSS”

eventProps.description = “creating an event for testing”

def openNms = OpenNmsEventDatasource.get(name:"OpenNMS") openNms.sendEvent(eventProps)

How about opening a ticket in the ticketing system?

def serviceDesk = RsTicket.get(name:"MyServiceDesk") def props = [:] props.object = "LabDevice1" props.eventName = "Down" props.description = “creating an event for testing” serviceDesk.createTicket(props)

What if I just want to send an snmp trap to another management system?

def trap = SNMPTrap.get(name:"MoM") def eventProps= [:] eventProps.enterprise = ".1.3.6.1.4.1.88888.12" eventProps.generic = 6 eventProps.specific = 1 eventProps.varbinds = [] trap.send(eventProps)

Note that RapidOSS is using a different interface/protocol behind the scenes for each of these systems. For Netcool JDBC (or SNMP Trap), for EMC/Smarts Java API, for OpenNMS TCP socket, etc. RapidOSS handles the complexities and idiosyncrasies of the interfaces provided by the external systems and providing the script developer a simple, consistent structure to work with, and all this without inventing a new, proprietary and crippled language (thanks to Groovy!)