Solving this issue is not a straightforward task.

Identifying the problem involves debugging, which is most likely related to JavaScript due to the presence of the 'undefined' term in the URL. The culprit could be any JavaScript code that automatically resolves a URL in the browser, such as setting the src attribute for an image tag or a css-image attribute. Personally, I recommend using Firefox with Firebug installed for effective troubleshooting.

Initial Firebug Configuration

If you are new to Firebug, you need to enable all panels after installing and restarting Firefox with Firebug. To access Firebug, click on the fire bug icon in the top right corner of your browser or press F12. Navigate through the tabs like 'Console', 'Script', 'Net', and activate them by reading the panel instructions. You may need to refresh the page for proper functionality.

If no 404/red requests are visible

If you cannot locate any problematic requests, it means that they are not triggered by your tests. Experiment further with different actions on the page until the request appears in the Net panel. The key is to trigger the request somehow; if it doesn't show up, then you are missing the action causing it.

Conclusion

Pinpointing the exact issue might not be simple, but following the steps outlined above can help you get closer to the root cause. It's often something unexpected that leads to such problems.

After analyzing a forum post, I successfully reverse-engineered the "Complitly" Chrome Plugin/malware. It was evident that this extension was injecting an "improved autocomplete" feature that sent out "undefined" requests to any website with input text fields named "search", "q", and more.

Further investigation revealed that the enable.js file (part of Complitly) checked for a global variable called "suggestmeyes_loaded" to determine if it had already been loaded, functioning like a Singleton pattern. Disabling the plugin simply required setting this variable to false.

To combat the malware and prevent the influx of "undefined" requests, implement the following script on pages containing search fields:

<script type="text/javascript>
    window.suggestmeyes_loaded = true;
</script>

In addition to sending unwanted requests, this malware also redirects users to a site called "searchcompletion.com," which may display competitor ads. This threat should not be taken lightly.

You've successfully identified that the issue of undefined is related to a JavaScript problem. If your website users have not reported any error pages, there are some steps you can take to troubleshoot.

When JavaScript is used to set or change image locations, it's possible that an undefined value may end up in the URI.

In such cases, the browser will still attempt to load the image without displaying AJAX errors, but there will be clues: it will send specific headers like Accept:, indicating image types such as image/jpeg, image/png, ....

Once you confirm this header behavior, you can isolate the issue to images only. However, pinpointing the root cause may require some time and effort :)

Update

To aid in debugging, you could modify the $.fn.attr() function to trigger the debugger whenever something is assigned to undefined. Here's an example:

​(function($, undefined) {
    var $attr = $.fn.attr;

    $.fn.attr = function(attributeName, value) {
        var v = attributeName === 'src' ? value : attributeName.src;

        if (v === 'undefined') {
            alert("Setting src to undefined");
        }

        return $attr(attributeName, value);
    }
}(jQuery));

After thorough investigation, certain key points have been confirmed regarding this issue:

- The problem occurs on pages without any javascript, indicating it is not a programming error within the page itself.

- Some users are unaware of the issue and continue to browse normally.

- The glitch typically occurs shortly after loading the page.

- It does not affect every user.

- The issue spans across various browsers (Chrome, IE, Firefox, Mobile Safari, Opera).

- It also impacts multiple operating systems (Linux, Android, NT).

- This problem arises with different web servers in use (IIS, Nginx, Apache).

- There have been instances of Googlebot encountering the same issue after following a link, hinting at potential plugin involvement.

- The theory that plugins may be causing the problem, notably Complitly, has gained traction among researchers.

- However, the presence of the issue on mobile browsers complicates the plugin explanation.

- System administrators have found success in reducing occurrences by implementing specific javascript code to deceive Complitly into thinking it has already initialized.

- A proposed solution for nginx involves returning a 204 response for URLs ending in "undefined", effectively maintaining the user's browsing experience without disruption.

- If users navigate to an "undefined" URL variant, the browser will display a changed address but refrain from reloading the page.

- Users experiencing this anomaly would essentially receive a seamless, uninterrupted browsing experience.

It appears that there may be a race condition where a variable is not properly initialized before being used. Since this issue does not seem to relate to AJAX based on your feedback, there are several methods you can employ to troubleshoot and resolve the issue.

Implement a JavaScript exception logger: By setting up a JavaScript exception logger, you can capture and track most unexpected JavaScript errors in your logs. It is recommended to place this logger before any other scripts run. Any programmatic errors will be surfaced here, allowing you to address them effectively. Here is an example implementation:

window.onerror = function(message, file, line) {
    var encodedMessage = window.encodeURIComponent(message);
    new Image().src = "/jslog?msg=" + encodedMessage + "&filename=" + window.encodeURIComponent(file) + "&line=" + window.encodeURIComponent(line) + "&url=" + window.encodeURIComponent(window.location.href);
};

Check for references to window.location: Review all instances where window.location is manipulated and ensure proper error handling or checks for undefined values. For instance:

function updateLocation(loc) {
    typeof loc === 'undefined' && window.onerror(...);
    window.location.href = loc;
}

Alternatively, a more concise approach could be:

window.setLocation = function(url) { 
   /undefined/.test(url) ? 
         window.onerror(...) : window.location.href = url;       
}

function updateLocation(loc) {
    window.setLocation(loc);
} 

If you require detailed stack traces, consider exploring: https://github.com/eriwen/javascript-stacktrace

Detect and handle unresolved links with invalid URLs: In addition to window.location, investigate unhandled DOM links for any incorrect URL patterns by attaching a check after jQuery loads:

$("body").on("click", "a[href$='undefined']", function() {
    window.onerror('Bad link: ' + $(this).html());
});

We hope these suggestions assist you in pinpointing and rectifying the issue. Happy debugging!

Could this possibly be related to an adblocker problem? It seems that each time a specific user accesses /folder/page.html, there is then a subsequent request to /folder/undefined based on the IP address in the logs.

Can anyone offer guidance on why my website is substituting a specific *.webp image with "undefined" once it loads across various browsers? Could this be related to hosting webp images on the site?

I encountered a similar issue (specifically receiving /null 404 errors in the console) that I was able to solve with the assistance of @andrew-martinez's solution.

The problem stemmed from using img tags with an empty src attribute:

<img src="" alt="My image" data-src="/images/my-image.jpg">

Originally, my intention was to delay loading the image manually by setting the src attribute through javascript which led to conflicts when using iDangerous Swiper.