hook_filter() and Finding Context in D6

Drupal's filter system is a pretty nifty thing- you can grab text coming through the system and modify it to your hearts content. This makes for great things like replacing various kinds of tokens, automatically making URLs link, and so on. I've been looking at the wordfilter module to check for "bad words" coming through the text.

One of the things that this module lacks is logging of the users who are using "bad words". Being able to track usage by user creates the possibility of creating specific kinds of actions around the user- settings various flags, demoting permissions, alerting admin, etc.

It seems as though this would be fairly straight forward to approach- you add a logging function in the hook_filter() $op == 'process' and you are done with it.

Unfortunately (at least as far as I can see) figuring out where the $text came from that is being filtered is not in the actual hook_filter itself. This means to log a user or a node that is getting filtered is rather complicated- or hacky. I came up with the following solution. It is not pretty, and I hope somebody else has a better idea!

/**
 * Check the filtered text for any words that have been replaced, if
 * so, log these
 * @param $text
 * @return unknown_type
 */
function wordfilter_log_text_log($text) {
    // We need to see if the replacement happened by comparing the before and
    // after of the text replacement. This adds overhead to each filter op
    // but since this is cached it should not be a significant performance hit
    if ($text != wordfilter_filter_process($text)) {
        // get the stack of function calls
        $backtrace = debug_backtrace();
        // We are looking for the node_view function call to get the NID
        // that is being processed
        foreach ($backtrace as $function_call) {
            // Log nodes
            if ($function_call['function'] == 'node_view') {
                    // extract the node
                $node = $function_call['args'][0];
                 // add a CID as null
                 $node->cid = null;
                 // Now we log this information
                wordfilter_log_bad_words($node);
                // we have done our logging, exit.
                return $text;
            }
            // Log comments
            elseif ($function_call['function'] == 'theme_comment_view') {
                // extract the comment
                    $comment = $function_call['args'][0];
                // add the node's VID to the comment
                $comment->vid = $function_call['args'][1]->vid;
                    wordfilter_log_bad_words($comment);
                // we have done our logging, exit.
                  return $text;
                }
            }
        }
  return $text;
}

I'm not sure how much of an overhead the debug_backtrace() adds- as filters can be cached it should not be that big a deal, but the real issue to me is that filters should probably have some context to them... Or maybe I'm missing something.. perhaps my use case is an outlier.

Arguably, this could be done with hook_nodeapi, but I like using hook_filter as it fits with the flow of code (from my perspective anyway).