ප්‍රොග්‍රෑම් එකේ බග් එකක් නෙමෙයි, ඩෙපෙන්ඩන්සි එකේ සැඟවුණු ප්‍රශ්නයක්!

තාක්ෂණ ලෝකයේ, විශේෂයෙන්ම සොෆ්ට්වෙයාර් සංවර්ධනයේදී, 'ඒක මගේ මැෂින් එකේ නම් වැඩ කරනවා' කියන කතාව අහලා නැති කෙනෙක් නැතුව ඇති. ඒත්, මේ සිදුවීම ඊටත් වඩා අමුතුයි. එකම කෝඩ් එක, එකම බ්‍රාන්ච් එක, එකම ඇප්ලිකේෂන් එක වුණත්, සංවර්ධක කණ්ඩායමේ එක් කොටසක VMs වල නම් කිසිම ගැටලුවක් නැතුව වැඩ කළා. අනිත් කොටසේ VMs වල නම් හැම වෙලේම අසාර්ථක වුණා. මේක මුලින්ම පෙනුණේ පරිසරය (environment) සම්බන්ධ ගැටලුවක් විදිහට. හැබැයි, මේක සොයා බැලීම පටන් ගත්තම, ඒක ලොකු පාඩමක් උගන්වන සුපිරි ඩිබග් එකක් වුණා.

සැඟවුණු ගැටලුවක් සොයාගැනීම

කණ්ඩායමේ සමහර සංවර්ධකයන්ට එකම ෆීචර් එක ටෙස්ට් කරනකොට අස්ථාවර හැසිරීමක් (inconsistent behavior) දැනෙන්න ගත්තා. මුලින්ම හැමෝම හිතුවේ පරිසරයෙම ප්‍රශ්නයක් කියලා. ඒ නිසා VMs වල configuration, network settings, install කරපු software, deployment එකේ වෙනස්කම් - ඔය හැමදෙයක්ම සසඳලා බැලුවා. හැබැයි, හැම පරීක්ෂණයකින්ම ආවේ එකම උත්තරේ: හැමදෙයක්ම හරි. ඉතින්, ප්‍රශ්නය පරිසරය නෙමෙයි කියලා තේරුණා.

ඊට පස්සේ, ප්‍රශ්නය විසඳන්න වෙනස් විදිහකට කල්පනා කරන්න පටන් ගත්තා. 'මේ VMs වල මොකක්ද වෙනස්?' කියලා ඇහුවා වෙනුවට, 'Request එකක් යවන එකේ ඉඳන් Response එකක් එනකම් හරියට මොනවද වෙන්නේ?' කියලා ඇහුවා. මේ ප්‍රශ්නය නිසා අවධානය පරිසරයෙන් ඈත් වෙලා, ඇප්ලිකේෂන් එකේ HTTP layer එක පැත්තට ගියා.

ඊළඟට, දෙපැත්තේම generated වුණු requests සහ responses සැසඳුවා. Headers, payloads, API errors, business logic - කිසිම අවුලක් පෙනුණේ නැහැ. එකම request එකෙන් දෙන්නේ විවිධ ප්‍රතිචාරයක් එන්නේ ඇයි කියලා මුලින්ම තේරුණේ නැහැ. ඊට පස්සේ, කවුරුත් ප්‍රශ්න නොකරපු දෙයක් ගැන බලන්න පටන් ගත්තා: HTTP client එක. ඒ Project එකේ තවමත් පරණ RestSharp version එකක් පාවිච්චි වෙමින් තිබුණා. ඒකේ තවත් ගැඹුරට ගියහම, පුදුම සහගත දෙයක් එළි වුණා. පරණ RestSharp versions වල built-in serializer එකක් විදිහට SimpleJson පාවිච්චි වුණා. මේක කවුරුවත් හිතාමතාම තෝරගත්ත දෙයක් නෙමෙයි, ඒක Projecct එකේ අවුරුදු ගාණක් තිස්සේ තිබුණා. ඒ වෙනකම් කවුරුවත් ඒක ගැන ප්‍රශ්න කරලා තිබුණේ නැහැ.

සැඟවුණු ඩෙපෙන්ඩන්සි එකේ බලපෑම

ප්‍රශ්නය විසඳගන්න ලැබුණු ලොකුම සාර්ථකත්වය ආවේ infrastructure එක ගැන හිතන එකෙන් ඈත් වෙලා, serialization ගැන අවධානය යොමු කරපු වෙලාවේ. Serialization කියන්නේ application එකේ හරිම අමුතු තැනක තියෙන දෙයක්. අපි ඒ ගැන හිතන්නේ හරිම අඩුවෙන්. Object එකක් JSON බවට, ආයේ JSON එකක් Object බවට convert කරන එක ඒක කරනවා කියලා අපි විශ්වාස කරනවා. ඒක හරි යනකොට, ඒක පේන්නේ නැහැ. ඒත්, ඒක හරි නොගියොත්... කිසිම දෙයක් තේරුම් ගන්න බැරි වෙනවා. ප්‍රශ්නේ business logic එක නෙමෙයි. API එක නෙමෙයි. Database එක නෙමෙයි. ඒක තිබුණේ මේ හැමදේටම යටින් නිහඬව වැඩ කරපු, පරණ serialization layer එක.

ඒ ඩෙපෙන්ඩන්සි එක ගැන පරීක්ෂණ කරනකොට, මේක අපේ Project එකට විතරක් සීමා වුණු දෙයක් නෙමෙයි කියලා දැනගත්තා. RestSharp 107 version එක එනකොට, SimpleJson සම්පූර්ණයෙන්ම අයින් කරලා, System.Text.Json වලට මාරු වෙලා තිබුණා. ඒකට හේතුව විදිහට පරණ architecture එකත්, serialization වල තියෙන අමුතුකම් (quirks) ගැනත් Mention කරලා තිබුණා. මේක දැනගත්තට පස්සේ, ප්‍රශ්නය දිහා බලන විදිහම වෙනස් වුණා. රෝග ලක්ෂණ වලට බෙහෙත් කරනවා වෙනුවට, ඒ පරණ ඩෙපෙන්ඩන්සි එක අයින් කරන එක ගැන අවධානය යොමු කළා.

ප්‍රශ්නයට විසඳුම

ඒ වැරදි හැසිරීම වටේට workaround එකක් හදන්න යනවා වෙනුවට, SimpleJson මත යැපුණු පරණ RestSharp implementation එකෙන් ඈත් වෙලා, serialization approach එක update කළා. මේ වෙනස්කම් දෙපැත්තේම VMs වල test කරලා බලපු ගමන්, අස්ථාවර හැසිරීම නැතිවෙලා ගියා. Application එක හැම තැනම එකම විදිහට වැඩ කළා. ඒක business logic එක වෙනස් කරපු නිසා නෙමෙයි. VMs configure කරපු නිසා නෙමෙයි. ඒක, application එකේ අඩිතාලමේ නිහඬව කොටසක් වෙලා හිටපු technical debt එකක් අයින් කරපු නිසා.

මේ බග් එකෙන් ඉගෙන ගත්ත දේ

මේ සිදුවීම, environment-specific issues සොයා බැලීමේ ආකාරය සම්පූර්ණයෙන්ම වෙනස් කළා. Code එක environments වලට අනුව වෙනස් විදිහට වැඩ කරනකොට, environment එකටම දොස් පැවරීම හරිම ලේසියි. සමහර වෙලාවට ඒක ඇත්ත වෙන්නත් පුළුවන්. ඒත්, සමහර වෙලාවට ඇත්තම වරද, ඔයාගේ code එකට යටින් තියෙන layers වල සැඟවිලා ඉන්නවා. අවුරුදු ගාණක් update නොකරපු dependency එකක්. ඔයා දන්නවත් නැතුව project එකේ තියෙන serializer එකක්. හැමෝම අමතක කරපු library එකක්, මොකද ඒක 'හරි යනවා' කියලා හිතාගෙන හිටියා. ඒක හරි යනකම්.

Takeaways:

• ඔයාගේ code එකට එහායින්, ඒක යටින් තියෙන libraries ගැනත් සොයා බලන්න.
• Environment-specific bugs හැම වෙලාවෙම infrastructure bugs වෙන්නේ නැහැ.
• Legacy dependencies හඳුනාගන්න අමාරු හැසිරීම් ඇති කරන්න පුළුවන්.
• Dependency එකක maintainers ඒක සම්පූර්ණයෙන්ම redesign කරලා තියෙනවා නම්, ඒකට හේතුව දැනගන්න එක වටිනවා.

මේ bug එකෙන් ලැබුණු ලොකුම පාඩම RestSharp ගැන නෙමෙයි. ඒකේ තිබුණේ curiosity එක ගැන. උත්තරේ අපේ application code එකේ තිබුණේ නැහැ. ඒක අපි ගොඩ දෙනෙක් කවදාවත් බලලා නැති dependency එකක් ඇතුළේ සැඟවිලා හිටියා. සමහර වෙලාවට, අමාරුම bugs කියන්නේ ඔයා ලියපු ඒවා නෙමෙයි. ඒ, ඔයා අවුරුදු ගාණක් තිස්සේ නොදැනුවත්වම ship කරපු ඒවා.