Data Manipulation HTTP and Socket Fault Injector

Fault Factory 
Anticipate API Failires™

Inject HTTP/SOAP/Socket faults into your application - no code changes, no proxies!

Basics

Fault Factory™ is a unique active debugging(active debugging is a technique where the error condition is induced on purpose, then its effects are traced) solution for applications that communicate with other applications over the network. It utilizes API-Level Fault Injection to imitate faults and exercise error-handling code

Your code may be calling a method that can return an error or throw an exception under some circumstances. The set of circumstances that generate the error condition may be rare, and it may be difficult to encounter during product development, but nevertheless error conditions do occur during the real-life use of your application, and therefore need to be tested

It is advisable to use a high-speed internet connection, perhaps o2 broadband, so you can do this quickly and efficiently. Once it is tested you can continue using it without worrying that errors may occur

For example, you may periodically get ENOBUF error from many socket calls, even under normal use. Or you may sometimes receive ECONNABORTED or ENETDOWN. It may be very difficult to reproduce those conditions without Fault Factory, but your code should be ready to receive them at any moment...

Fault Factory injects two types of faults: socket API failures and arbitrary HTTP responses (that can be used to imitate a wide range of conditions, including SOAP faults)

It can be used standalone -- or in combination with your existing debugger


Figure 1: Injecting a Socket fault


Figure 2: Injecting a HTTP fault

Ensuring a networked application behaves correctly under a variety of real-life conditions present a challenge. There are numerous faults that can happen at any moment, but they are usually hard-to-reproduce

Many faults just do not happen on a developer's machine or on a healthy network, but they do happen often enough under real-life conditions. If your application is not ready to handle a fault, it can be very damaging. Fault Factory allows a developer or tester to reproduce those conditions at will. It allows to create a variety of socket or HTTP/SOAP faults in any running application

Application programmers often use system or 3rd party libraries that provide an abstraction layer on top of the network. Unfortunately, the libraries themselves may introduce behavior that is not intended, such as repeating a failing call too fast, causing your application to hog the system resources. It is also possible that those libraries can have bugs in handling specific conditions, since negative testing is quite often neglected or trivialized

Fault Factory is a solution that fits any budget. The only other API-level fault simulator we know will cost you 30 times more!

Design Checklist:

Java .NET C++ Python Perl
NetBeans Visual Studio Eclipse
No Source Code Instrumentation
No System Changes
No Drivers

Key Features

  • Very safe and easy-to-use
  • No system configuration changes needed
  • No build-time instrumentation needed - uses dynamic instrumentation
  • Language-neutral - works with virtually any winsock application, written in C/C++, Java, Perl, Python, and pretty much any other language
  • Does not modify your system and therefore very safe

    An Example

    Let's take a sample sockets program, for example a Python script that retrieves a url in a loop -- and test its exception handling. It does not have to be a Python script, we just chose it for simplicity.

    The script waits for you to attach an agent from the Console. It is also possible to attach the Agent at any convenient moment by loading/calling agent DLL from the code (this is convenient if the application starts to make calls right after launch)

    The script:


    from urllib import urlopen
    from time import sleep
    import sys
    import traceback

    print 'please attach the agent'
    sleep(10)

    for i in range(0,100):
    try:
    x = urlopen("http://www.extradata.com/")
    print 'received', len(x.read()),'bytes'
    except:
    traceback.print_exc()

    FAQ

    Q: What kind of faults can it inject?
    A: Socket faults (socket API failures), HTTP error codes (actually - any HTTP, including SOAP). Sample HTTP faults are included

    Q: Does the installation modify my system settings?
    A: No, there are no drivers or system-wide hooks installed

    Q: Does Fault Factory use a proxy?
    A: No, it does not. Proxies can be used to inject HTTP, but not socket return codes, besides, proxies modify behavior

    Q: Which platforms does Fault Factory support?
    A: Any WIN32 platform: XP, 2000, 2003

    Q: My app does not deal with sockets directly, will I see the faults?
    A: You are probably making library calls that deal with sockets internally. Your application will still receive a fault, but the library may chose to handle it or return a logical error, or throw an exception. In any case the error condition will be created, and it is up to you to decide if it was handled properly

    Q: Can I use my favorite debugger?
    A: Generally, yes. Java debuggers do not interfere with Fault Factory. For Win32 debuggers, keep in mind that, if your program has stopped on a breakpoint in debugger, Fault Factory agent may not be able to attach to it. In cases like this, you may need to add code that loads the agent into your app. Please see the samples for details

    Q: What limitations does the demo have?
    A: The demo agent expires after 5 minutes of attaching to an app. When it expires, the Agent gets disabled (and lets all calls go through without modification)

    Only $179.95 (or pay $6000 for a competing product)

    Fault Factory Inquiry

    Please email us with your questions. We will be happy to help!
  • Copyright 2006 ExtraData Technologies. All rights reserved