உங்கள் கிராஷ் அறிக்கைகள், ஒருவரால் படிக்கப்படுகின்றன

Crashlytics எது செயலிழந்தது என்று சொல்கிறது. நாற்பதில் எது உங்கள் நேரத்திற்குரியது என்று அது சொல்லாது, அதை விளக்கி எழுதாது அல்லது டிக்கெட்டை திறக்காது. இது ஒவ்வொரு மணிநேரமும் அதைச் செய்கிறது, மேலும் ஒரே செயலிழப்பை இரண்டு முறை கோப்பு செய்யாது.

கிராஷ் வகைப்படுத்தலை அமைக்கவும்இலவசமாக முயற்சிக்கலாம். நிறுவுவதற்கு எதுவும் இல்லை.

இது எவ்வாறு இயங்குகிறது

மூன்று படிகள், அதில் எதுவும் “கட்டமைத்தல்” இல்லை.

01
Firebase மற்றும் GitHub ஐ இணைக்கவும்
கிராஷ் அறிக்கைகளுக்கு உங்கள் Google கணக்கு, சிக்கல்களுக்கு உங்கள் GitHub. பிறகு உங்கள் பயன்பாட்டின் கிராஷ்கள் எந்தக் களஞ்சியத்தைச் சேர்ந்தவை என்று சொல்லுங்கள் — அது உங்களுக்காகத் திறக்கும் கோப்பில் ஒரே ஒரு வரி.
02
இது ஒரு மணிநேரத்திற்கு ஒரு கிராஷைத் தேர்ந்தெடுக்கிறது
இது தரவரிசைப்படுத்தப்பட்ட அறிக்கையைப் படித்து, ஏற்கனவே பதிவு செய்யப்பட்ட அனைத்தையும் தவிர்த்து, மீதமுள்ள மிக மோசமான ஒன்றை எடுத்துக்கொள்கிறது. ஒரு இயக்கத்திற்கு ஒன்று, சரியாகச் செய்யப்படுகிறது — ஒரு மணிநேரம் காத்திருப்பது பெரிய விஷயம் இல்லை, அரைகுறை பிழை அறிக்கை யாருக்கும் உதவாது.
03
உங்களுக்கு ஒரு சிக்கலும், கிராஷ் பற்றிய ஒரு குறிப்பும் கிடைக்கும்
தாக்கம், ஸ்டேக் டிரேஸ் மற்றும் என்ன நடக்கிறது என்பது பற்றிய அதன் புரிதலுடன் கூடிய ஒரு GitHub சிக்கல். பிறகு Crashlytics சிக்கலில் அது எதைத் திறந்தது என்ற குறிப்பு, எனவே கிராஷைப் பார்க்கும் எவரும் ஒரு ஏஜென்ட் இங்கு வந்துள்ளதைப் பார்க்க முடியும்.

இது என்ன செய்ய முடியும்

எந்த கிராஷ் மிக முக்கியமானது என்று இதற்குத் தெரியும்
மூல நிகழ்வு எண்ணிக்கைகளை விட பாதிக்கப்பட்ட பயனர்கள், ஒரு வருடமாக நீடிக்கும் ஒன்றை விட தற்போதைய பதிப்பில் உள்ள பின்னடைவு, மற்றும் ஒரு ஃப்ரேம்வொர்க்கிற்குள் உள்ள ஒன்றை விட உங்கள் குறியீட்டைச் சுட்டிக்காட்டும் ஸ்டேக் டிரேஸ் ஆகியவற்றுக்கு இது முன்னுரிமை அளிக்கிறது. நீங்கள் வேறுபட முடிவெடுக்க ஏதுவாக, எதைத் தவிர்க்கிறது, ஏன் தவிர்க்கிறது என்பதையும் இது கூறுகிறது.
இது ஒரே பிழையை இரண்டு முறை பதிவு செய்யாது
இது பதிவு செய்யும் ஒவ்வொரு கிராஷும் அதன் Crashlytics ID-க்கு எதிராகப் பதிவு செய்யப்படுகிறது. நினைவகம் இல்லாத ஒரு மணிநேர வேலை மதிய உணவிற்கு முன்பே ஒரே டிக்கெட்டை பன்னிரண்டு முறை திறக்கும், இதுவே யாராவது அதை நிரந்தரமாக முடக்கச் செய்வதற்கான அதிவேக வழியாகும்.
பாதியில் நிறுத்தப்பட்ட இயக்கம் அடுத்த இயக்கத்தால் தொடரப்படும்
தான் செய்யப்போகும் காரியத்தைச் செய்வதற்கு முன்பே இது எழுதி வைக்கிறது. ஒரு இயக்கம் பாதியில் நின்றால், அடுத்த இயக்கம் அந்தச் குறிப்பைப் படித்து, பிரச்சனை உண்மையில் பதிவு செய்யப்பட்டுள்ளதா எனப் பார்த்து, மீண்டும் முதலிலிருந்து தொடங்காமல் அல்லது இரட்டிப்பாகப் பதிவு செய்யாமல் அங்கிருந்து தொடர்கிறது.

இது எவ்வாறு அமைக்கப்பட்டுள்ளது

நீங்கள் உள்நுழைவதற்கு முன் எதைப் பெறுகிறீர்கள் என்பதை அறிந்துகொள்வதற்கான செயல்பாட்டு முறைகள்.

சூழல்: சாண்ட்பாக்ஸ் மற்றும் ஷெல் எதுவும் இல்லை — இது ஒரு API-ஐப் படித்து மற்றொரு API-க்கு எழுதுகிறது. அட்டவணைப்படுத்தப்பட்ட இயக்கங்கள் உங்கள் அமர்வின் நகலைப் பெறாமல், ஒரு அட்டவணைக்கு மட்டும் பயன்படுத்தக்கூடிய குறுகிய கால சான்றைப் பெறுகின்றன.
கருவிகள்: அறிக்கைகள், சிக்கல்கள், நிகழ்வுகள் மற்றும் குறிப்புகளுக்காக MCP வழியாக Firebase Crashlytics; கோப்பு செய்ய MCP வழியாக GitHub. தனது சொந்த பதிவுகளுக்காக readFile, writeFile, editFile, glob மற்றும் grep, அத்துடன் getCurrentTime, scheduleRun, listSchedules மற்றும் cancelSchedule.
மாடல்: Claude Sonnet 5-க்கு நிலைநிறுத்தப்பட்டு, அதன் பின்னால் Haiku 4.5 உள்ளது. இங்கு தீர்மானிப்பதே முதன்மையானது — ஒரு செயலிழப்பு ஒருவரின் கவனத்திற்குரியதா என்பதைத் தீர்மானித்து, அதை மூடிவிடாமல் அவர்கள் நடவடிக்கை எடுக்கும் வகையில் ஒரு அறிக்கையை எழுதுகிறது.
தொடக்கக் கோப்புகள்: ரெபாசிட்டரி மேப்பிங் தவிர வேறு எதுவும் இதில் தொடக்கத்தில் சேர்க்கப்படவில்லை. கோப்பு செய்யப்பட்ட பதிவு எதுவும் இல்லாததே, இதுதான் முதல் இயக்கம் என்பதை முதல் இயக்கத்திற்குத் தெரிவிக்கிறது.
எது சேமிக்கப்படும்: இது கோப்பு செய்தவை அமர்வுடன் அப்படியே இருக்கும், அதனால் தான் மீண்டும் செய்யாமல் மணிநேரத்திற்கு ஒருமுறை இதனால் இயங்க முடிகிறது. இயக்கங்களுக்கு இடையே எதுவும் நீக்கப்படுவதில்லை.

மக்கள் இதனிடம் கேட்கும் விஷயங்கள்

“இப்போது எது அதிகமாக கிராஷ் ஆகிறது?”
“மிக மோசமான கிராஷைப் பதிவு செய்து, இனிமேல் ஒவ்வொரு மணிநேரமும் சரிபார்க்கவும்.”
“எந்தெந்த கிராஷ்களை ஏற்கனவே பதிவு செய்துள்ளீர்கள்?”
“மணிநேர இயக்கத்தை நிறுத்தவும்.”

இது எதைச் செய்யாது

இவை ஒவ்வொன்றும் நாங்கள் எதிர்கொண்ட உண்மையான கட்டுப்பாடே தவிர, திட்டமிடப்பட்ட அம்சம் அல்ல.

இது கிராஷ்களைப் படித்து சிக்கல்களைப் பதிவு செய்கிறது. இது தீர்வை எழுதுவதில்லை — அது ஒரு தனி வேலை, மேலும் உங்களிடம் GitHub Copilot இருந்தால் அது சிக்கலை அதற்கு வழங்கிவிடும்.
Firebase-ஐ இணைப்பது அது பயன்படுத்துவதை விட அதிகமான அணுகலைக் கேட்கிறது. Crashlytics-க்கு வாசிப்பு மட்டும் ஸ்கோப்பை Google வெளியிடவில்லை, எனவே சம்மதத் திரையில் “view and administer” என்று கூறுகிறது. இது அறிக்கைகளைப் படித்து குறிப்புகளைச் சேர்க்கிறது; டோக்கன் ஒருபோதும் மாடலை அடையாது.
ஒரு இயக்கத்திற்கு ஒரு கிராஷ். ஒரு இயக்கத்தின் படிகளை விட அதிகமான கிராஷ்கள் உள்ளன, மேலும் நான்கு பகுதி அறிக்கைகளை விட ஒரு முழுமையான பிழை அறிக்கை சிறந்தது.
திட்டமிட்ட இயக்கங்கள் உங்களிடம் எதையும் கேட்க முடியாது. பதிலளிக்க அங்கு யாரும் இருக்க மாட்டார்கள், எனவே அவை எழுதப்பட்ட அறிவுறுத்தலின்படியே செயல்படுகின்றன — அதனால் தான் அதை பதிவு செய்வதற்கு முன் அந்த அறிவுறுத்தலை நீங்கள் அங்கீகரிக்க வேண்டும் என்று கேட்கிறது.

எந்த மாடல் இதைச் சிறப்பாகச் செய்கிறது

இந்த ஏஜென்ட்டின் உண்மையான இயக்கங்களின் மீது அளவிடப்பட்டது, ஒவ்வொரு மாடலுக்கும். ஒரு இயக்கம் தானாகவே பதிலை உருவாக்கியபோது முடிந்ததாகக் கணக்கிடப்படுகிறது — எதுவும் தோல்வியடையவில்லை, யாரும் எதையும் அனுமதிக்கக் கேட்கப்படவில்லை, மேலும் அது படிகள் தீர்ந்துவிடவில்லை. மூன்று நெடுவரிசைகளையும் ஒன்றாகப் படியுங்கள்: விட்டுக்கொடுப்பதன் மூலம் வேகமாக முடிக்கும் மாடல் முதலில் மோசமாக மதிப்பெண் பெறுகிறது, அரைப்பதன் மூலம் எல்லாவற்றையும் முடிக்கும் மாடல் இரண்டாவதில் மோசமாக மதிப்பெண் பெறுகிறது.

மாடல்	நிறைவு விகிதம்	இடைநிலைச் செலவு	இடைநிலை நேரம்	இயக்கங்கள்
claude-sonnet-5anthropic	72%	$0.236	80வி	50

நிறைவு விகிதம்: நீங்கள் தலையிட வேண்டிய அவசியமின்றி வேலையை முடித்த இயக்கங்கள்.
இடைநிலைச் செலவு: ஒரு சாதாரண இயக்கத்திற்கு ஆகும் செலவு, கிரெடிட்களில்.
இடைநிலை நேரம்: முதல் செய்தியிலிருந்து பதில் வரும் வரையிலான கணக்கிடப்பட்ட நேரம்.

ஒவ்வொரு வரிசையின் பின்னால் உள்ள இயக்கங்களின் மீதான இடைநிலைகள். ஒரு மாடல் இந்த ஏஜென்ட்டில் 3 இயக்கங்களைக் கொண்டவுடன் தோன்றும், மேலும் ஒரு எண்ணிக்கை எவ்வளவு தங்கியுள்ளது என்பதை நீங்கள் தீர்மானிக்க இயக்க எண்ணிக்கை காட்டப்படுகிறது.