Errors and AJAX

Monday 20th of November 2017 04:46:12 AM In case you haven't heard by now, the hottest buzzword in the realm of web technology is AJAX (as coined in an Adaptive Path essay). The crux of the AJAX framework is the XMLHttpRequest JavaScript object which allows client-side developers to send and receive XML documents over HTTP without interrupting the user, and without hacking around with hidden frames. Now, some might shudder at the notion of allowing client-side developers who might be more used to validating forms and animating rollover images to suddenly be responsible for traversing XML documents and negotiating HTTP headers, but without risk, there is no reward. And just to soothe any lingering trepidation, I will demonstrate how to use XMLHttpRequest to not only add previously impossible or infeasible features, but also to reduce errors and improve quality.

XMLHttpRequest and XML DOM for JavaScript Basics

First, we need to set up a few ground rules. The XMLHttpRequest object in particular, and XML DOM in general, is widely supported in any recent browser (IE, Mozilla, Safari, Opera) although, as usual, Microsoft has taken a slightly different tack on implementation and requires some special care. While our more progressive friends directly implement XMLHttpRequest, IE requires that you instantiate an ActiveXObject with the same properties. An excellent overview and full feature list is available at the Apple Developer Connection site.

A basic example follows:

var req;
function postXML(xmlDoc) {
if (window.XMLHttpRequest) req = new XMLHttpRequest();
else if (window.ActiveXObject) req = new ActiveXObject("Microsoft.XMLHTTP");
else return; // fall on our sword
req.open(method, serverURI);
req.setRequestHeader('content-type', 'text/xml');
req.onreadystatechange = xmlPosted;
req.send(xmlDoc);
}
function xmlPosted() {
if (req.readyState != 4) return;
if (req.status == 200) {
var result = req.responseXML;
} else {
}
}

The potential uses for this powerful tool are vast, and exploration of the possibilities has just begun. But before anyone gets carried away with trying to create an XML circus on the web, I suggest we set up a safety net to keep any high-flyers from breaking their necks.

JavaScript Error Handling Basics

JavaScript has come a long way since its earlier versions, which were crude, lacking in features, and just poorly implemented. Newer browsers not only support the try/catch/finally keywords you will recognize from C++ and Java, they also implement an onerror event that can trap any error conditions that arise during runtime. Usage is pretty straightforward:

function riskyBusiness() {
try {
riskyOperation1();
riskyOperation2();
} catch (e) {
} finally {
}
}
window.onerror = handleError; // safety net to trap all errors
function handleError(message, URI, line) {
return true; // this will stop the default message
}

A Practical Example: Persisting Client-side Errors to your Server

Now that we have the basics of XMLHttpRequest and JavaScript error handling, let's look at an implementation that ties the two together. You'd think that JavaScript errors would be easy to spot given the prevalent "Yellow Triangle of Death", but I still see them slip past the QA departments of several blue chip organizations' public-facing web sites.

Figure 1

So, here I will present a method for trapping errors and logging them back to the server in the hope that someone might be alerted to fix it. First, let's consider our client. The client should provide a class to be used as a singleton Logger object that can transparently handle the gritty details.

First we create the constructor:

function Logger() {
this.req;
this.errorToXML = errorToXML;
this.log = log;
}

Next, we define the method that will serialize an Error object into XML. By default, an Error object only has two properties, name and message, but we will also check for a third called location which may be useful.

function errorToXML(err) {
var xml = '<?xml version="1.0"?>\n' +
'<error>\n' +
'<name>' + err.name + '</name>\n' +
'<message>'  + err.message + '</message>\n';
if (err.location) xml += '<location>' + err.location +
'</location>';
xml += '</error>';
return xml;
}

Next is the log method. This is the meat and potatoes of the script that really brings together the principles described above. Notice that we are using the POST method for our call. What I am essentially creating here is a bespoke web service that is write-only and creates new records on each successful request. Therefore, POST is the only appropriate option.

function log(err) {
if (window.XMLHttpRequest) this.req = new XMLHttpRequest();
else if (window.ActiveXObject) this.req =
new ActiveXObject("Microsoft.XMLHTTP");
else return; // throw up our hands in despair
INPUT:focus {background: yellow;}

This style would only be applied to an element as long as it was in focus. As soon as the user switched from one input to another, the styles would be removed from the former and applied to the latter. This is a welcome capability, as it reduces the need for using JavaScript to create such effects.

TIP

There are serious issues related to document reflow with :hover and :focus. Take, for this.req.open("POST", "/cgi-bin/AjaxLogger.cgi"); this.req.setRequestHeader('REFERER', location.href); this.req.setRequestHeader('content-type', 'text/xml'); this.req.onreadystatechange = errorLogged; this.req.send(this.errorToXML(err)); this.timeout = window.setTimeout("abortLog();", 10000); }

The last part of our class definition is to create an instance of the Logger class. There should be only one instance of this class.

var logger = new Logger();

The last two functions are just there for housekeeping. If something goes wrong while logging the error, there is not much we can do except bother the user. Hopefully, it will never come to this. These are not class methods since the events will not have references to our object, but will refer to the logger instance we just created.

function abortLog() {
logger.req.abort();
alert("Attempt to log the error timed out.");
}
function errorLogged() {
if (logger.req.readyState != 4) return;
window.clearTimeout(logger.timeout);
if (logger.req.status >= 400)
alert('Attempt to log the error failed.');
}

All of the preceding code can be wrapped up into one .js file that can be included on any (or every) page in your site. Here is an example of how to include it and put it to good use:

<script type="text/javascript" src="Logger.js"></script>
<script type="text/javascript">
function trapError(msg, URI, ln) {
var error = new Error(msg);
error.location = URI + ', line: ' + ln; // add custom property
logger.log(error);
warnUser();
return true; // stop the yellow triangle
}
window.onerror = trapError;
function foo() {
try {
riskyOperation();
} catch (err) {
err.location = location.href + ', function: foo()';
logger.log(err);
warnUser();
}
}
function warnUser() {
alert("An error has occurred while processing this page."+
"Our engineers have been alerted!");
location.href = '/path/to/error/page.html';
}
</script>

Now that we have seen how to integrate the logger into our HTML pages, all that is left is to define some way of receiving and translating the message. I have chosen a lowest common denominator approach and built a CGI script in Perl that uses one of my favorite modules, XML::Simple, to parse the post data, and CGI::Carp to pipe the results directly to httpd error log, thus saving your system administrators from having to monitor another log. This script also includes some good examples of appropriate response codes for different success and failure conditions.

use CGI;
use CGI::Carp qw(set_progname);
use XML::Simple;
my $request = CGI->new();
my $method = $request->request_method();
# method must be POST
if ($method eq 'POST') {
eval {
my $content_type = $request->content_type();
if ($content_type eq 'text/xml') {
print $request->header(-status =>
'415 Unsupported Media Type', -type => 'text/xml');
croak "Invalid content type: $content_type\n";
}
# when method is POST and the content type is neither
# URI encoded nor multipart form, the entire post
# is stuffed into one param: POSTDATA
my $error_xml = $request->param('POSTDATA');
my $ref = XML::Simple::XMLin($error_xml);
my ($name, $msg, $location) =
($ref->{'name'}, $ref->{'message'}, '');
$location = $ref->{'location'} if (defined($ref->{'location'}));
# this will change the name of the carper in the log
set_progname('Client-side error');
my $remote_host = $request->remote_host();
carp "name: [$name], msg: [$msg], location: [$location]";
};
if ($@) {
print $request->header(-status => '500 Internal server error',
-type => 'text/xml');
croak "Error while logging: $@";
} else {
# this response code indicates that the operation was a
# success, but the client should not expect any content
print $request->header(-status => '204 No content',
-type => 'text/xml');
}
} else {
print $request->header(-status => '405 Method not supported',
-type => 'text/xml');
croak "Unsupported method: $method";
}

And that's all there is to it! Now, the next time some slippery JavaScript gets into the system, you can expect your log monitors to start flashing red lights and your client-side developers to get calls in the middle of the night.

styles from any LINK element with aREL of alternatestylesheet unless that style sheet is selected bythe user.

1.4.2. The STYLE Element

The STYLE element, which is a relatively new formatting model is not exactly simple.

8.4.2. Inline Formatting

As we saw in Chapter 4, "Text Properties", all elements have aline-height. This fact has a great deal to do withhow inline elements are displayed, and it needs to be covered indetail before we move on.

The only drawback to this ability is a small one, but you'rebound to run into it eventually. Suppose you want to set the top andleft margins for H1 elements to be 10 pixels, andthe bottom and right margins to be 20 pixels. In that case, you haveto write the following:

H1 {margin: 10px 20px 20px 10px;} /* can't be any shorter */

Unfortunately, there is no way to cut down on the number of valuesneeded in such a circumstance.</P>

Even though the LINE tags don't exist, thesituation is the same as if they did. Each line of text inheritsstyles from the paragraph, so they may as well be contained withintags such as these. Therefore, the only reason we createline-height rules for block-level elements is sothat we don't have to explicitly declare aline-height for all its inline elements, fictionalor otherwise.