iFountain.com blogs

iFountain’s RapidInsight 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 RapidInsight 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 RapidInsight 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 RapidInsight 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 RapidInsight 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 RapidInsight. With the version 3.3, RapidInsight 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 RapidInsight v3.3 will reduce the barriers to using this technique and make it easy to implement heartbeat monitoring.

Managing Planned and Unplanned Maintenance with RapidInsight

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. RapidInsight 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, RapidInsight 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 RapidInsight, maintenance management functionality is implemented as operations (methods) of a class, hence fully programmable, can be automated. Using integration capabilities of RapidInsight, 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 RapidInsight 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 RapidInsight 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 RapidInsight include in the solutions directory. Further information can be found in the integrators' guide.

RapidInsight 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 RapidInsight 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 RapidInsight 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 RapidInsight.

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 RapidInsight, 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 RapidInsight itself. How to create an event in RapidInsight? The mechanism is simple, put the event properties into a map and call an operation (method of a class) to create the event in RapidInsight 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 = “RapidInsight”

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 =  “RapidInsight”

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 RapidInsight 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. RapidInsight 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!)

Search At the Front and Center of IT Operations Management

berkay — Sun, 22 Feb 2009 16:08:24 -0800

Google revolution is spreading. Prior to search, hierarchical directories (like Yahoo) were the dominant
way to organize and find information on the web. As the amount of information increased, the directory paradigm run into problems handling the scale, and Google's search paradigm with it's simplicity has become ubiquitous way to find information. Users are at ease with search, as a result, search paradigm has been spreading.

Search had already come to desktop. Google Desktop brought powerful search engine into the desktop. And with Windows 7, Microsoft went beyond search as an application and put search at the core of the user experience. Just as search has displaced the directories on the web and become the primary mechanism to find information, it has become the primary mechanism in Windows 7 for most things from starting applications to finding files, displacing Windows Explorer.

I see a lot of parallels in the IT management world. Search is moving from being an often poorly
implemented feature to the core. There is ever increasing amount of IT management data and that is locked inside various IT management tools. Users have to know where the data is and traverse through however the data is organized in the particular tool. Something better is needed and search paradigm seems to fit, hence number of IT management companies like Splunk, Paglo and Tideway emphasize search as the solution.

Search is at the heart of RapidInsight, our IT Operations Management solution. RapidInsight has a built-in modeling engine to model the IT environment (classes, properties, relations, operations, etc.) and a search engine (Compass/Lucene) as the data store. The combination of object based modeling and search engine provides a powerful platform for IT operations management solutions.

RapidInsight user interface takes full advantage of the power of search to make it as easy as possible for users to find information they are looking for. Almost everything in the user interface is a search operation. Users can query the repository using Google like searches, in addition to being able to navigate the repository through the model.

Ability to use free form searches practically eliminates the learning curve since most users are familiar with searching information using Google. Users don't have to know how the data is organized nor they need to master a query language like SQL. The same simple searches can be used for all the
IT management information in the repository, events, inventory, trouble tickets, configuration changes, etc.

In the journey to create the next generations IT Operations Management Console, moving search to the center is an essential step.

RapidCMDB, an open source federated CMDB solution for the enterprise

berkay — Sun, 08 Feb 2009 15:21:14 -0800

The problem is well known and stated over and over again throughout the last decade. Most IT organizations are structured around functional silos of expertise and too focused on technology, hence there is a gap between IT organizations and the business. It is mostly agreed that IT organizations need to move toward service management, but there are different schools of thought on how to get there.

My personal journey in this realm started over a decade ago when I worked for a very large system integrator/outsourcing company that was organized in very distinct, geographically dispersed silos.

At least some people in senior management was well aware of the problems inherent to this organizational model, and tasked the tools team to alleviate this problem and enable horizontal communications among the silos, slowly triggering organizational change. We had Unicenter TNG available in the organization and had to built a solution around it.

The solution was very imaginatively named “Information Window” and marketed internally to various departments. The core idea was to provide a unified view of the entire IT infrastructure, the services and their dependencies to all the users in the organization facilitating better understanding of the environment and more effective collaboration among number of silos. How is that for grand ambitions :)

Over the years, I've been part of number of projects where the buzzwords, methodologies, and tool sets have changed but more or less had the same objectives the Information Window project had. Over a decade later, we're still searching for better ways to solve the same problems, moving towards service management, better collaboration, more efficient processes, aligning IT with business, etc.

I've seen the same patterns from that first project in many of the projects I worked later on. The lessons I've learned stayed with me through the years.

Change is hard, organizational politics is fact of life, stop complaining about it and learn how to work with it.
There is more than one “true” way. Some level of skepticism (not cynicism) is healthy.
The more disruption there is to existing tools and systems, the more collaboration and participation is required, more likely you are to fail.
If the number of people/entities that needs to collaborate/participate is high, strong senior management buy-in and active sponsorship is a must
The more you have to rip and replace existing tools, the more opponents you will gain.
The path of least resistance is implementing solutions that can augment the existing solutions and show value with minimal disruption to existing systems (at least at first)

The purpose of this long narrative is to give some context to the choices we've made when designing RapidCMDB, an open source federated CMDB solution for the enterprise. There are two schools of thought about ITIL/ITSM/BSM/CMDB implementations. Idealists vs pragmatists.

Idealists emphasize how life altering these projects are for the organizations. Lots of preparation is needed, everybody needs to be educated (converted?), processes need to be changed etc. In short, full commitment of the organization and more importantly senior management is needed. Their conviction is driven from experience. There are too many examples of failures when full organizational commitment is not there.

Pragmatists on the other hand advocate more of a sneak attack. Forget about the ideal solution they say and look for the low hanging fruit that may have high impact. If possible, leverage existing systems to add value even if they are not exact fit, or implement the solution for couple of critical highly visible services. Fight the battles you can win so to speak.

As I stated above, I don't think there is a single true way of doing things. Different organizations have different needs and capabilities. If an organization is ready to make fundamental moves and senior management is onboard and ready to lead, the return from full ITSM/CMDB/BSM implementations would be higher for the organizations. And if not, no need for despair, pragmatist approach is a valid one.

RapidInsight (built on RapidCMDB technology) is a pragmatic solution. It does not compete with traditional CMDB products. It is designed as a federated solution from the ground up (not an afterthought) to leverage existing systems and data sources easily. We believe ITSM/CMDB/BSM projects don't have to be multi-year, multi-millon dollar projects, and it is feasible and may be even advisable to begin with an approach that leverages existing management tools and data sources, and what better way to give it a try but with an open source project?

RapidInsight v3.1 has just been released along with the website to support open development.

Looking forward to hearing your thougths.

RapidInsight: what is it good for? - Integration in the presentation layer

iFountain — Sun, 25 Jan 2009 08:49:51 -0800

In a previous post, I discussed different management systems integration types: data layer integration, functional integration, event integration and presentation layer integration.

Problem:
You have number of different management tools for different management disciplines (fault mgmt, configuration & change mgmt, service desk, etc.), and technologies (Unix, Windows, LAN, WAN, Applications, etc.). Yet services you provide span multiple technologies and platforms, and you need to provide information to internal/external customers about the services they use. We'll consider can think about the scenario described in this post to understand what type of information you may need to provide to your users.

Distribution
You can't install the client for each management tool for every user/customer that needs access to information, that's for sure. But wait, these tools have web based clients so you don't have to install the clients, customers can use the web based client. Assuming that web clients don't have java applets ActiveX, and you don't suffer from JVM conflicts, etc. you got this one covered. One down, what other problems are there?
Training and support
The customers may be able to access to each of the management tools using a web browser, but the client for each management tool still provides a different user interface? Can the customers just "use" the clients? or do they need training? Are you geared to provide support for large number of users trying to figure out how to use these tools?
User identification and authentication
Will the user be able to use all the different tools with a single username and password? How will this work, will you need to synchronize the usernames and password among all the tools? May be you can user and external authentication system (like LDAP) for all tools? Can you? Will you use a single sign-on solution to be able to identify and authenticate each user? Does the single sing-on solution support all the management tools you have?
Authorization
Does the client for each management tool have sufficient user access levels and data segmentation to ensure the users can only see and do what they are supposed to be able to? (Assuming you're able to implement consistent user access levels for each of the tools).
Consistency, flow of information and usability
Will the user be able to find the related information from each of the tools easily? For example, when there is a problem, will the user need to navigate monitoring UI to see the events, then go to ticketing UI to see the related tickets and then to the change management UI to see related configuration changes? Will the user need to "remember" information while navigating from one UI to the next?

Solution:
As stated above, there are many challenges when implementing a solution to provide IT operations management information to the customers/users. Integration in the presentation layer (philosophy that is embraced by RapidInsight solution) is the pragmatic approach to provide IT operations management information to internal and external customers, avoiding the problems discussed above. I can summarize the philosophy as the following:

The user interface should present the information to business users and customers in the context they are familiar with and not necessarily how the information is presented by different management tools.
The native clients of the management tools are often not suitable for the business users and customers as they are often designed for the heavy, more technical users in mind.
Business users and customers typically need to have access to a small subset of the data (that is relevant to them) and the functionality provided by the native clients of the management tools. The user interface should only provide the necessary, relevant data and functionality and nothing more to minimize/eliminate training need and support requirements.
Projects often fail or not get completed on time due to complex web of dependencies among different initiatives. Implementation of the solution should not have dependencies to implementation of other projects or functionality/architecture not yet available.
The user interface should take advantage of the advancements in the rich internet applications (RIA) technologies (ajax, flash, etc.), focus on usability and not replicating the functionalities provided by full clients.
The solution should not have an all or nothing approach and provide an incremental improvement path when feasible.

Following this philosophy, RapidInsight provides easy access to IT management information gathered from different management tools, in-house databases, commercial systems, etc. on-demand or continuously. Users can access real-time and historical events from the monitoring systems, trouble tickets, change records, configuration data for the related devices, performance graphs, etc. through a single, consistent web based application, navigating IT management data from different systems seamlessly

RapidInsight: what is it good for? - The broken client

iFountain — Fri, 23 Jan 2009 05:02:04 -0800

When learning about new products, I often find myself trying to understand what problem the product is trying to solve and often without much success. It is crucial for vendors to express this clearly, yet it's not so easy. We sometimes get lost talking the jargon, the features, etc. and forget about the fundamental question. What is this product good for?

So I remind myself not to loose track of where we (iFountain) have started. RapidInsight is a direct result of number of problems we have run into repeatedly in the field. It's our attempt to have a repeatable solution to common problems that are typically solved as ad-hoc custom projects or by forcing product to perform “unnatural acts”.

So in this series of posts. I'll discuss the problems we have encountered in the field. The problems we are trying to solve with RapidInsight.

Problem: The client is broken

When deploying an application that will be used by many people, the typical options have been fat clients and html based web applications. Both options have pluses and minuses.

Fat clients (aka client/server architecture) provide a richer UI, more functionality, but the client needs to be installed on every PC, therefore overhead is very high. About 10 years ago, I remember Unicenter TNG client install taking over an hour. There were patches, and patch groups, etc. that had to be installed in a specific order. Considering that management tools are implemented to increase productivity, needless to say, a solution that generates so much overhead is not ideal for in many cases.

Html based web applications have the advantage to be deployed quickly. There is only one copy of the application, hence it is easy to maintain and the overhead is minimal. The problem with html based applications is that the UI is limited, and not suitable to represent all types of information. Regardless, html applications are quite popular and good enough in many cases.

People have been trying to compensate for the shortcoming of both of these options in number of ways. In a past life, we had used Citrix (Windows Terminal Services) to give people access to the Unicenter console, rather than installing on each PC. It was not “supported” but it worked most of the time.

On the web applications side, the typical solution to resolve the usability issues has been the use of java applets in the browser. Java applets do provide a richer UI and solve the distribution problem to a degree, yet they introduce other problems:

Not all browsers have a JVM and applications often require specific versions of JVM which creates compatibility problems, therefore support overhead.
Use of java applets often mean just moving the client piece of a client server application to the browser rather than re-architecting the application. The client server applications do not work well over the web with high latency connections (when client and server are connected via WAN). As a result usability suffers significantly despite availability of a rich UI.
Java applets also can be very large, several megabytes in size, causing long startup times.
It is very difficult (if possible) to integrate the user interfaces of two java applets even though they may be running in the same browser

To address the problems stated above, a new set of technologies loosely named as Rich Internet Applications, RIAs have emerged. These technologies use the capabilities of the browser (javascript and/or flash) to create rich user interfaces. The browser typically receives the data as XML/JSON from the server, the data is processed within the browser and represented using UI components, etc. The user interfaces provided by RIA technologies may not be as rich as the native desktop applications (at least not yet) however they are getting closer by the day. Usability is much better than html based applications yet they are almost as easily distributable as the html based web applications.

RapidInsight takes advantage of the recent advancements in RIA technologies, to provide a light web based user interface that can be used in any browser, eliminating JVM version conflicts, large initial downloads etc. and providing a richer interface than html based applications at the same time.

The user interface does not have to refresh to update the data. It polls the data in the background, and updates the UI as the data is updated. It provides menus to allow in-context actions, etc.

RapidInsight client uses standard web services API to interact with the server, which allows us to decouple the server and the client, giving us more flexibility in development of the client.

In the next post, I'll talk about the challenge to segment data and so that users can only see the data they should be able to see.

The dream team, the tale of Smarts, APG and RapidInsight

berkay — Wed, 21 Jan 2009 12:18:59 -0800

Fault management, performance management and event management trio of tools are typically at the heart of network management solutions. Although there are some integrated solutions that do offer components for all these management disciplines, organizations with large or mission critical networks often choose to use combination of tools that have the best functionality at each area . As a result, integration among these tools becomes crucial for the overall solution to be effective is supporting IT operations.

Customers have to balance the desire to use the best tools for each discipline with minimizing implementation/integration risk, and have been gravitating toward working with a single supplier for these tools with the hope that it would eliminate finger pointing between vendors in case of a problem and the vendor would have better integration among its own products.

Unfortunately, apart from having a single entity to blame in case of problems, working with one vendor does little to reduce implementation risk, especially in case of Big 4 in IT management, as they have build their product portfolio through acquisitions. As a result, products often have little in common, not integrated with each other, do not share a data model, etc. and integration is very difficult, costly and carries high risk. For example, IBM's portfolio of fault, performance and event management products include Precision(Riversoft), Provisio (Quallaby) and Netcool (Micromuse), each was developed by a different company. CA offers eHealth (Concord), Spectrum (Aprisma) and Unicenter (CA), etc. HP portfolio is in no better shape.

Even when the vendors claim integration among their own products, quality of integration is often quite low, limited to a exchange of traps between products, or launching of one from the other, and may be a common user interface. There is often no common data model, each product does its own discovery and polling, there are problems with consistent naming of the objects, etc.

Consequently, implementation of a fully integrated solution is a lot more expensive than led on by the vendors or anticipated by the customers. Ongoing maintenance of the solution is often resource intensive therefore cost of ownership is also very high. The promises that the integration between the products would get better in time have not been kept. After many years, little headway is made, as better integration often requires complete overhaul/rewrite of these products.

IMO, EMC/Smarts has been the best network fault management solution available for quite some time. It's ability to discover all the layers of the network topology (Layer2/3, routing, mpls, etc.), represent it using a common object model and use it for automated root cause analysis is still unmatched.

Watch4Net APG is a great performance monitoring and reporting solution that should be considered by anyone looking for a performance management solution. But for EMC/Smarts customers APG is a slam dunk. It's natively integrated with EMC/Smarts, automatically polling data from EMC/Smarts domains, instead of performing its own discovery and polling (though it can), eliminating naming problems and double polling. To the best of my knowledge, EMC/Smarts-APG combination provides the most powerful integrated fault/performance management solution currently available in the market. No contest.

Our product, RapidInsight, completes the trio as the event management solution, providing powerful integration, automation and presentation capabilities. RapidInsight integrates seamlessly with both EMC/Smarts and APG, and consolidates events and topology data from both systems, provides a unified, consistent, web based user interface to work with wealth of operational information contained in EMC/Smarts and APG, integrates with other operations systems and automates operational tasks.

RapidInsight-EMC/Smarts-APG combination offers best of both worlds to customers: Best functionality at each management disclipline with seamless integration, minimizing integration risks, implementation times and ongoing administrative overhead. Please contact us or Watch4Net to learn more and give it a try. We're confident that you'll find it worth your time.