A few weeks ago, I engaged with a client who had a real issue. They sold a variety of goods via a website (if this was the 90s, they would have been called an ‘e-tailer’), and had been receiving intermittent double orders through their ecommerce system. Some customers were charged two times for one order. This led, as you can imagine, to very unhappy customers. This had been happening for a while and, unfortunately, due to some external obstacles, internal staff were not available to investigate the issue–they had their hands full with an existing higher priority project.
I was called in to see if I could solve this issue. I had absolutely no familiarity with the system. But in less than ten hours of time, I was able to find the issue and resolve it. How I approached the situation can be summed up in five rules:
Number one: define the problem. Ask questions, and capture the answers. What is the exact undesired behavior? When is the undesired behavior happening? What seems to trigger it? When did it start? Were there any changes that happened recently? Does the client have reproduction steps?
I gathered as much information as I could, but keep it high level. I asked for architecture and system diagrams. For the history of the application. For access to all systems that could possibly be relevant (this will save you time in the future). For locations of log files, source repositories, configuration files. For database credentials and credentials for third party systems like CC processors. It is important at this time to resist the temptation to dive in–at this point the job is to get a high level understanding so I can be efficient in the next steps.
You will get speculation about what the solution is when you are asking about the problem. Feel free to capture that, but don’t be influenced by it.
Number two–find the finish line. After getting a clear definition of the problem, I looked in the orders database and find out if the double orders were showing up there. They were, which was a clue as to which part of the system was malfunctioning, but more importantly let me see the effectiveness of any changes I was making. It also lets the customer know the objective end goal, which can be important if this is a t&m project, and it let me know the end state to which I was headed–important for morale. (BTW, don’t do fixed bids for this type of project–overruns will be unpleasant, and there will be overruns.)
I was able to write a SQL script to find double orders over a given time frame. I ended up writing a script which emailed the results of this query to myself and the client nightly, as an easy way to track progress. The results of this query were a quantifiable, objective measure of the problem.
Number three–start where you are familiar. I could have dove in and looked at the codebase, but due to my problem definition, I knew that there had been no changes to the checkout portion of the code base for years. I also was unfamiliar with the particular software that managed the ecommerce site and could have wasted a lot of time getting up to speed on the control flow. Instead, once I had the SQL query, I could find users that had been double charged, and look at their sessions in the web server logs. I’ve been looking at apache http logs for over a decade and was very familiar with this piece of the system.
Number four–follow your nose. I followed a few of the user sessions using grep and noticed some weirdness in the logs. There were an awful lot of messages that indicated the server had been restarted, and all the double orders I looked at had completed 5-6 seconds after the minute changed. (It’s hard to define weirdness explicitly, which is why it behooved me to start with a portion of the system that I was experienced with–it made the “weirdness” more obvious.) From here, I ended up looking at why or how the server was being restarted regularly. Ended up finding an errant cron job which was restarting the server often enough that the ecommerce system was getting confused and double booking orders–once before the restart and once after. This was easily fixed by commenting out the cron job.
Number five–know when to stop. This ecommerce system obviously had a logic flaw–after all, restarting the web server shouldn’t cause an order to be entered twice, whether you restart it every hour or once a year. I could have dug through the code to find that out. But instead, I commented out the cron job, let the system run for a week or so and waited for more double orders. There were none, indicating that the site was low traffic enough that whatever flaw was present didn’t get exercised often, if at all. I confirmed with the client that this situation met his expectations of completeness, and called it good.
Being thrown into a new system, especially when troubleshooting, is a difficult task. I am thankful the client was relatively responsive to my questions, and that pressure, while present, wasn’t intense. These five steps should help you, if you are put in any troubleshooting situation.