Waarom het vertrouwen in uw gebruikers om fouten te melden het domste is dat u ooit zult doen

Als u ongelukkige gebruikers heeft, hoe weet u dat dan?

We houden allemaal van code.

Als we nadenken over codering, stellen we onszelf meestal voor aan het bouwen.

Bouw functies, nieuwe innovaties, nieuwe functionaliteit en opwindende updates waar gebruikers dol op zullen zijn. Het is dat mentale beeld dat ons enthousiast maakt over de dingen die we vervolgens kunnen bouwen.

Maar de romantische beelden in ons hoofd worden vaak niet vertaald naar de realiteit.

Softwareontwikkelaars besteden het grootste deel van hun tijd aan andere taken dan bouwen. Ze wonen vergaderingen bij, bespreken specificaties, plannen en ruimen bestaande code op. En natuurlijk is hun favoriete activiteit het repareren van bugs.

Ik heb nog geen ontwikkelaar ontmoet die graag problemen in hun codebase vindt. Maar deze frustratie komt waarschijnlijk voort uit het feit dat het vinden en reproduceren van fouten lang duurt.

Historisch gezien moesten softwareontwikkelaars de naald in de hooiberg zoeken. Ze moesten zelf de antwoorden vinden in plaats van te vertrouwen op die screenshots van gebruikers die in een Microsoft Word-document waren gepost.

We zijn er allemaal geweest!

Welke browser en versie gebruikt u? Welk besturingssysteem? Kun je me precies vertellen waar je op hebt geklikt? Wat gebeurde er toen? Op welke pagina was je eerder? Hoe ben je op dit scherm terechtgekomen?

Zoveel vragen, zo weinig (nuttige) antwoorden.

Een probleem oplossen kan een eeuwigheid duren!

Op gebruikers vertrouwen om problemen te melden

Veel software-ontwikkelingsteams vertrouwen nog steeds op gebruikers om problemen met hun applicaties te melden.

Wat tegenwoordig nogal gek is.

Het is net als fastfoodrestaurantketens. Ze leggen de verantwoordelijkheid op klanten om hun eigen tafels op te ruimen door trays en afvalstortplaatsen aan te bieden. Het eten van het restaurant was misschien verschrikkelijk. Maar de klant kon rustig zijn tafel afruimen, zijn afval weggooien en weglopen. Tenzij ze de tijd nemen om te klagen, gaan medewerkers ervan uit dat nog een tevreden klant net het restaurant heeft verlaten.

Maar ze zullen nooit meer terugkeren.

Sommige ontwikkelaars verwachten dat gebruikers voor zichzelf zorgen wanneer ze hun applicaties gebruiken. Immers, als niemand problemen meldt, hebben we er toch geen - toch? De verantwoordelijkheid voor uw gebruikers om de problemen die zij ervaren te melden, is beperkend. U zult ongeveer een procent van het totale aantal exemplaren zien dat uw hele gebruikersbestand beïnvloedt, en technische details zijn dun en inconsistent.

Ontwikkelaars zullen meer tijd besteden aan het oplossen van het probleem - met behulp van kleine stukjes informatie - dan aan het oplossen ervan. Dat is als ze het probleem überhaupt kunnen vinden.

Uw software is niet zo goed als u denkt

Ik sprak met een vriend van mij die voor een grote online retailer werkt. Hij legde me uit hoe ze een groot probleem in hun online bestelsysteem hadden gevonden dat niemand had geweten.

Na enkele dagen onderzoek konden ze het probleem niet meer vaststellen. Op dat moment besloten ze een speciale tool uit te proberen om fouten in hun applicatie te detecteren en diagnosticeren.

Wat ze vonden was alarmerend.

De tool heeft vastgesteld dat een van de acht servers onvoldoende geheugen heeft en fouten heeft gemaakt. Dit zorgde ervoor dat de betalingsstroom van de gebruiker volledig tot stilstand kwam.

Eén op de acht gebruikersuitchecksessies was verbroken.

Het vinden en oplossen van dit probleem resulteerde in een onmiddellijke stijging van de omzet van $ 20.000 per maand! Mensen liepen niet langer tegen problemen aan tijdens het aankoopproces.

Ze schatten dat het meer dan 5.000 gebruikers had getroffen - maar ze hadden er slechts twee supporttickets over ontvangen.

Hoewel het team het probleem graag vond, was er ook een verpletterende teleurstelling. Een onbekende fout had waarschijnlijk geresulteerd in meer dan $ 100.000 aan gemiste inkomsten.

Jezelf e-mailen als er fouten optreden, is een dom idee

U kunt zitten kijken naar een livestream van problemen die zich voordoen in uw codewaarschuwingslogboeken. En je kunt hiervoor een warm lichaam inhuren terwijl je slaapt. Of u kunt uzelf e-mailen wanneer er een onverwerkte uitzondering optreedt - lijkt een geweldig idee!

Totdat je het doet.

Als u dit instelt, kan het er zo uitzien:

openbare ongeldige TryProcessLineNumber (int lineNumber)
{
    proberen
    {
        ProcessLineNumber (lineNumber);
    }
    vangst (uitzondering ex)
    {
        LetMyselfKnowViaEmail ("Er is iets misgegaan:" + bijv. Bericht);
    }
}

Maar pas op voor de problemen die het kan veroorzaken.

E-mailfouten kunnen geschikt zijn voor kleinere nevenprojecten en persoonlijke projecten. Maar zodra je dat uitbreidt, worden de dingen rommelig. Heel, heel rommelig:

  • Diagnostische gegevens zijn beperkt
  • Het is moeilijk om meldingsregels in te stellen en dingen beginnen luidruchtig te worden
  • Een uitzondering gevangen in een oneindige lus kan 's nachts 50.000 e-mails naar uw inbox verzenden
  • Fouten hebben geen prioriteitsniveau of impactzichtbaarheid en lijken allemaal gelijk
  • Nadat je meer dan honderd e-mails hebt bereikt, stop je ermee ze te lezen

Niet lang nadat je jezelf fouten hebt gemaild, negeer je ze. Of je filtert ze in een map omdat er zoveel ruis is en er geen signaal is.

Je blijft achter om duizenden e-mails te doorzoeken op zoek naar de juiste foutinstantie.

We hebben iets slimmer nodig.

ELMAH - uw uitzonderingen vastleggen

ELMAH (Error Logging Modules and Handlers) is een applicatiebrede foutregistratiefunctie die volledig inplugbaar is. Het kan dynamisch worden toegevoegd aan een actieve ASP.NET-webtoepassing, of zelfs alle ASP.NET-webtoepassingen op een machine, zonder dat hercompilatie of herschikking nodig is.

ELMAH ondersteunt niet elke programmeertaal en elk platform. Omdat de functionaliteit vrij beperkt is bij het boren naar de hoofdoorzaak van een probleem, wordt het meestal gebruikt voor kleinere projecten. Het is tegenwoordig ook niet echt in actieve ontwikkeling, maar het is tenminste iets en het is gratis.

Elmah logging van fouten

ELMAH is eigenlijk een NuGet-pakket voor .NET-webtoepassingen. Het registreert elke uitzondering die zich op een of meer websites voordoet in de opslag die u kiest. In tegenstelling tot andere logboekframes, logt ELMAH automatisch in op elke uitzondering wanneer deze in de eenvoudigste vorm is geconfigureerd. Natuurlijk, er is een API die u kunt gebruiken om aangepaste fouten te registreren. Maar de meeste mensen gebruiken alleen het automatische gedeelte. In deze tutorial zullen we ons alleen richten op de basisonderdelen.

Hier is een geweldige zelfstudie over hoe u aan de slag kunt.

Speciale fout- en crashrapportagetools

Als u serieus bent in het omgaan met fouten en crashes in uw applicaties, gebruik dan een speciaal hulpprogramma voor foutcontrole. Het detecteert en diagnosticeert problemen die uw gebruikers automatisch beïnvloeden door een provider aan uw applicatiecode toe te voegen.

Het is een paar regels code - dat is alles wat nodig is.

Met een dergelijk hulpmiddel kunt u:

  • Verwijder lawaaierige uitzonderingen en focus op de dingen die ertoe doen, zoals gebruikers beïnvloeden
  • Stel configureerbare meldingen in via e-mail, Slack of HipChat
  • Gebruik één tool om meerdere talen en platforms bij te houden
  • Maak gebruik van foutgroepering voor vergelijkbare fouten
  • Houd uw hele team op de hoogte van fouten en hun oplossing
Gebruik een toegewijd software voor foutcontrole zoals Raygun

Dergelijke tools zijn niet goedkoop of gratis zoals de andere programma's die we hebben besproken, maar welke prijs zet je op je tijd? Stel dat u een gratis oplossing gebruikt. Vervolgens moet je drie uur stoppen met coderen terwijl je probeert een bug te reproduceren. Dit is eigenlijk een zeer slecht rendement op de investering.

Teams die snel willen verhuizen en gebruikers nieuwe functionaliteit willen bieden, zouden zeggen dat dergelijke professionele oplossingen elke cent waard zijn. Ze kunnen de tijd verkorten die ontwikkelaars doorbrengen met het repareren van bugs en ze terugbrengen naar codering en het bouwen van verbeteringen.

Zelfs als u denkt dat uw code perfect is en gebruikers geen problemen ondervinden, sluit u een tool als Raygun aan. Je zult versteld staan ​​van wat je vindt.

Neem een ​​proactieve benadering en pluk de vruchten

We houden allemaal van technologie om onze softwareproblemen automatisch op te lossen. Helaas denk ik dat we een tijdje weg zijn van zelfherstellende en zelfbewuste software.

U kunt ook oplossingen voor foutcontrole aansluiten op workflows voor ontwikkelaars om het oplossen van fouten en crashes te vergemakkelijken. Maar gegevens zijn vaak vervuild en gescheiden van context in andere systemen.

De toekomst van foutmonitoring ligt in het waarborgen dat alle teams - front end, back end, management of support - volledig zicht hebben op elk probleem dat hun gebruikers tegenkomen. En dan de mogelijkheid hebben om het meteen op te lossen.

Dit strekt zich ook uit tot opkomende trends in de continue leverings- en implementatieruimte. U kunt fixes toepassen en binnen enkele minuten na het identificeren van het probleem naar de productie verzenden. U hoeft geen weken te wachten voor de volgende grote implementatie.

Richt de focus op uw team bij het omgaan met fouten en crashes in uw eigen applicaties. Ontdek problemen voordat uw gebruikers dat doen en vertrouw niet op hen om fouten te melden.

Omdat ze dat niet zullen doen.