மூன்று codebase-களை ஆய்வு செய்ததில், OpenTelemetry (OTel)-ஐ நிறுவுவது மட்டுமே AI-உதவி பெறும் கோடிங் ஏஜெண்டுகளுக்கான (AI-assisted coding agents) பின்னூட்டச் சுழற்சியை (feedback loop) முழுமையடையச் செய்யாது என்பது தெரியவந்துள்ளது. ஒரு செயல்படும் சுழற்சி இல்லாமல், டெலிமெட்ரி (telemetry) ஏஜென்ட் எதை மாற்ற வேண்டும் என்று தீர்மானிக்க உதவ முடியாது, மேலும் டெவலப்பர்கள் மாடலுடன் (model) தொடர்பு கொள்ளாத ஒரு கருவியை நிறுவுவதில் நேரத்தை வீணடிக்கிறார்கள்.
ஏன் “observability-first” மனநிலை போதுமானதாக இல்லை
பல குழுக்கள் observability-ஐ ஒரு சரிபார்ப்புப் பட்டியலாக (checkbox) மட்டுமே கருதுகிறார்கள்: ஒரு tracing library-ஐப் பயன்படுத்துவது, ஒரு dashboard-ஐ இயக்குவது, அவ்வளவுதான் என்று நினைக்கிறார்கள். ஆனால் உண்மை நிலை என்பது மூன்று படிநிலைகளைக் கொண்ட ஒரு ஏணியாகும்:
- ஒரு observability நுட்பம் (mechanism) உள்ளது.
- அமைப்பு (system) உண்மையில் டெலிமெட்ரியை உருவாக்குகிறது.
- ஒரு AI ஏஜென்ட் அந்த டெலிமெட்ரியைப் பயன்படுத்தி ஒரு முடிவை எடுக்க முடியும்.
பெரும்பாலான திட்டங்கள் படிநிலை 1-லேயே முடங்கிவிடுகின்றன. ஒரு middleware சரியாக instrument செய்யப்பட்டிருந்தாலும், பயன்பாடு (application) அதை ஒருபோதும் அழைக்கவில்லை என்றால், அது எந்தத் தரவையும் உருவாக்காமல் செயலற்ற நிலையில் இருக்கும். ஒரு AI ஏஜென்ட் மூலக் குறியீட்டை (source code) ஸ்கேன் செய்யும்போது, அங்கு tracing code இருப்பதைப் பார்த்து அமைப்பு observable என்று நினைக்கும், ஆனால் இறுதியில் காலியான runtime தரவையே காணும். “ஒரு கருவியைக் கொண்டிருப்பதற்கும்” மற்றும் “ஒரு சுழற்சியைக் கொண்டிருப்பதற்கும்” இடையிலான இடைவெளியில்தான் முயற்சி தோல்வியடைகிறது.
பயன்பாட்டுத் தரவிற்கான ஆறு நிபந்தனைகள்
மூலத் தடயங்களை (raw traces) ஒரு AI கோடிங் ஏஜென்ட்டிற்கான பயனுள்ள உள்ளீடாக மாற்ற, டெலிமெட்ரி பின்வரும் ஆறு நடைமுறை நிபந்தனைகளைப் பூர்த்தி செய்ய வேண்டும்:
- Standardization (தரப்படுத்துதல்). ஏஜென்ட் தனிப்பயனாக்கப்பட்ட மேப்பிங் (bespoke mapping) இன்றி தரவைப் பகுப்பாய்வு செய்ய ஏதுவாக, நிலையான attribute பெயர்களையும் வகைகளையும் (types) பயன்படுத்த வேண்டும்.
- Propagation (பரப்பல்). அனைத்து சேவைகள் மற்றும் மொழி எல்லைகளுக்கும் இடையே ஒரே ஒரு trace identifier-ஐக் கொண்டு செல்ல வேண்டும், இது ஏஜென்ட் ஒரு முழுமையான (end-to-end) செயல்பாட்டை மீண்டும் கட்டமைக்க உதவும்.
- Discoverability (கண்டறியும் தன்மை). மாடல் கைமுறையாகத் தேடாமல் தரவைக் கண்டறிய ஏதுவாக, code-level hooks அல்லது எளிய CLI கட்டளைகள் மூலம் தரவை வெளிப்படுத்த வேண்டும்.
- Controllability (கட்டுப்பாட்டுத் தன்மை). தேவையற்ற spans-களால் ஏஜென்ட் திணறிவிடாமல் இருக்க, கால அளவு (time range) அல்லது முடிவுகளின் எண்ணிக்கையின் அடிப்படையில் தேடல்களைக் கட்டுப்படுத்த ஏஜென்ட்டிற்கு அனுமதி அளிக்க வேண்டும்.
- Accessibility (அணுகும் தன்மை). ஏஜென்ட் இயங்கும் அதே session-லேயே தரவை வாசிக்கக்கூடிய வகையில் வைத்திருக்க வேண்டும், இது ஒரு local file அல்லது stdout stream மூலம் இருப்பது சிறந்தது.
- Comparability (ஒப்பீட்டுத் தன்மை). ஒரு மாற்றத்தின் தாக்கத்தை ஏஜென்ட் அளவிட ஏதுவாக, ஒரே மாதிரியான சூழலில் “முன்” (before) மற்றும் “பின்” (after) ஸ்னாப்ஷாட்டுகளைப் (snapshots) பெறுவதற்கான வழியினை வழங்க வேண்டும்.
இந்தத் தூண்களில் ஏதேனும் ஒன்று இல்லையென்றால், பின்னூட்டச் சுழற்சி உடைந்துவிடும், மேலும் AI ஏஜென்ட் யூகங்களின் அடிப்படையில் செயல்படும்.
மேம்பாட்டிற்கு (development) கிளவுடை விட லோக்கல் பைப்லைன்கள் (local pipelines) சிறந்தது
Production சூழல்கள் கிளவுட் சார்ந்த telemetry collectors, aggregation சேவைகள் மற்றும் dashboards-களைச் சார்ந்துள்ளன. பெரிய அளவில் கண்காணிப்பதற்கு (monitoring at scale) அந்த பைப்லைன்கள் அவசியம், ஆனால் அவை நிமிட அளவில் தாமதத்தை (latency) ஏற்படுத்துகின்றன. தரவிற்காக நிமிடங்கள் காத்திருக்கும் ஒரு AI ஏஜென்ட்டால், வினாடிகளில் முடிவுகள் தேவைப்படும் ஒரு மேம்பாட்டுச் சுழற்சியில் (development loop) பங்கேற்க முடியாது.
நடைமுறைக்கு ஏற்ற மாற்று வழி ஒரு local telemetry pipeline ஆகும்:
- டெலிமெட்ரியை local files அல்லது stdout-க்கு எழுதவும். OTel, JSON அல்லது plain-text spans-களை நேரடியாக டெவலப்பரின் workspace-க்குக் கொண்டு செல்லும் exporters-களை ஆதரிக்கிறது.
- எளிய கருவிகள் மூலம் தரவை வெளிப்படுத்தவும். ஒரு சிறிய HTTP server, command-line query interface அல்லது ஒரு இலகுவான SQL wrapper மூலம் தேவைப்படும்போது traces-களை ஏஜென்ட்டிற்கு வழங்க முடியும்.
- ஏஜென்ட் மூல வெளியீட்டை (raw output) வாசிக்க அனுமதிக்கவும். JSON அல்லது Markdown வடிவங்கள், மொழி மாடல்கள் (language models) ஒரே edit session-லேயே தரவைப் பகுப்பாய்வு செய்யவும் ஒப்பிடவும் எளிதானவை.
மிகப்பெரிய அளவில் auto-instrumentation செய்வதைத் தொடங்குவது தேவையற்ற இரைச்சலை (noise) மட்டுமே சேர்க்கும். ஒரு முக்கியமான execution path-ஐத் தேர்ந்தெடுக்கவும்—உதாரணமாக ஒரு request handling routine அல்லது ஒரு build step—அதை end-to-end instrument செய்யவும். இந்தச் சங்கிலியை முழுமையாக்குங்கள்: Generate → Propagate → Store → Query → Compare. அந்தச் சுழற்சி சரியாக வேலை செய்தவுடன், அதை படிப்படியாக விரிவுபடுத்தவும்.
குழுக்கள் அடுத்து என்ன செய்ய வேண்டும்
- மிகவும் மதிப்புமிக்க flow-ஐக் கண்டறியவும். ஒரு மாற்றமானது அளவிடக்கூடிய செயல்திறன் (performance) அல்லது துல்லியத் தாக்கத்தை (correctness impact) ஏற்படுத்தும் குறியீட்டுப் பகுதியைத் தேர்ந்தெடுக்கவும்.
- அந்த flow-ஐ OTel மூலம் instrument செய்யவும். spans-களை உருவாக்க, தரப்படுத்தப்பட்ட attributes-களை இணைக்க மற்றும் trace context-ஐப் பரப்ப (propagate), அந்தந்த மொழிக்குரிய API-ஐப் பயன்படுத்தவும்.
- உள்ளூர் முறையில் (locally) ஏற்றுமதி செய்யவும். JSON வரிகளைத் திட்டக் கோப்பகத்தில் (project directory) உள்ள ஒரு கோப்பிற்கு எழுத அல்லது console-இல் அச்சிட exporter-ஐத் தயார் செய்யவும்.
- ஒரு query interface-ஐ வழங்கவும். trace ID மற்றும் கால அளவு (time window) அடிப்படையில் கோப்பை வடிகட்டும் ஒரு சிறிய script, ஏஜென்ட் சரியான தரவைப் பெற போதுமானது.
- தரவை AI ஏஜென்ட்டிற்கு வழங்கவும். “முன்” (before) trace-ஐக் கொண்டு மாடலுக்குத் தூண்டுதல் (prompt) அளித்து, ஒரு மாற்றத்தைக் கேட்கவும், பின்னர் புதுப்பிக்கப்பட்ட குறியீட்டை இயக்கி, ஒப்பீட்டிற்காக “பின்” (after) trace-ஐச் சேகரிக்கவும்.
- மீண்டும் மீண்டும் செய்யவும் (Iterate). ஒவ்வொரு வெற்றிகரமான சுழற்சியும் அந்த ஆறு நிபந்தனைகளையும் உறுதிப்படுத்துவதோடு, observable surface area-வையும் விரிவுபடுத்துகிறது.
Takeaway
OpenTelemetry உங்கள் குறியீட்டிற்கு tracing செய்வதற்கான ஒரு பொதுவான மொழியை வழங்குகிறது, ஆனால் அந்தத் தரவு ஆறு குறிப்பிட்ட நிபந்தனைகளைப் பூர்த்தி செய்து, ஒரு நெருக்கமான feedback loop-இல் உள்ளூர் ரீதியாகக் கிடைக்கும்போது மட்டுமே அந்த மொழி பயனுள்ளதாக மாறும். சிறிய அளவில் தொடங்குங்கள், ஒரு ஒற்றை flow-வை instrument செய்யுங்கள், ஒரு கோப்பிற்கு ஏற்றுமதி செய்யுங்கள், மேலும் AI agent அந்த traces-களை அங்கேயே படித்து ஒப்பிடுவதற்கு அனுமதிக்கவும். "என்னிடம் observability உள்ளது" என்பதிலிருந்து "எனது AI assistant உண்மையில் எனது குறியீட்டை மேம்படுத்த முடியும்" என்பதற்கான நடைமுறைப் பாதை அதுவாகும்.