ਸੰਦਰਭ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ ਅਪਵਾਦਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਡੈਕੋਰੇਟਰ ਬਣਾਉਣਾ

Azure ਫੰਕਸ਼ਨ ਇਵੈਂਟ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ ਸਟ੍ਰੀਮਲਾਈਨਿੰਗ ਐਰਰ ਹੈਂਡਲਿੰਗ

ਸਕੇਲੇਬਲ ਸਿਸਟਮ ਬਣਾਉਣ ਵੇਲੇ, ਅਪਵਾਦਾਂ ਨੂੰ ਖੂਬਸੂਰਤੀ ਨਾਲ ਸੰਭਾਲਣਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ Azure ਫੰਕਸ਼ਨਾਂ ਵਰਗੀਆਂ ਸੇਵਾਵਾਂ ਵਿੱਚ। ਇਹ ਫੰਕਸ਼ਨ ਅਕਸਰ ਆਉਣ ਵਾਲੀਆਂ ਘਟਨਾਵਾਂ ਨਾਲ ਨਜਿੱਠਦੇ ਹਨ, ਜਿੱਥੇ ਅਸਥਾਈ ਮੁੱਦਿਆਂ ਜਾਂ ਖਰਾਬ ਪੇਲੋਡ ਤੋਂ ਤਰੁੱਟੀਆਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ। 🛠️

ਇੱਕ ਤਾਜ਼ਾ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ, ਮੈਨੂੰ ਇੱਕ ਦ੍ਰਿਸ਼ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ ਜਿੱਥੇ ਮੇਰੇ ਪਾਈਥਨ-ਅਧਾਰਿਤ ਅਜ਼ੁਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਈ JSON ਇਵੈਂਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਸੀ। ਹਰੇਕ ਇਵੈਂਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨੀ ਪੈਂਦੀ ਸੀ, ਪਰ `JSONDecodeError` ਜਾਂ `ValueError` ਵਰਗੀਆਂ ਤਰੁੱਟੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਪੂਰੇ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਿਘਨ ਪੈ ਸਕਦਾ ਹੈ। ਮੇਰੀ ਚੁਣੌਤੀ? ਮੂਲ ਸੰਦੇਸ਼ ਅਤੇ ਸੰਦਰਭ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹੋਏ ਸਾਰੇ ਅਪਵਾਦਾਂ ਨੂੰ ਸਮੇਟਣ ਲਈ ਇੱਕ ਸਜਾਵਟ ਨੂੰ ਲਾਗੂ ਕਰੋ।

ਸੈਂਕੜੇ ਇਵੈਂਟ ਸੁਨੇਹੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰੋ, ਜਿੱਥੇ ਇੱਕ ਸਿੰਗਲ ਮੁੱਦਾ ਪਾਈਪਲਾਈਨ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਇਹ ਪੇਲੋਡ ਵਿੱਚ ਇੱਕ ਗੁੰਮ ਫੀਲਡ ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਇੱਕ ਬਾਹਰੀ API ਦੇ ਅਚਾਨਕ ਅਸਫਲ ਹੋਣ ਕਾਰਨ ਹੋ ਸਕਦਾ ਹੈ। ਟੀਚਾ ਸਿਰਫ ਗਲਤੀ ਨੂੰ ਲੌਗ ਕਰਨਾ ਨਹੀਂ ਸੀ, ਬਲਕਿ ਅਸਲੀ ਸੰਦੇਸ਼ ਅਤੇ ਅਪਵਾਦ ਨੂੰ ਇਕਸਾਰ ਫਾਰਮੈਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ, ਟਰੇਸੇਬਿਲਟੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ ਸੀ।

ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਮੈਂ ਪਾਈਥਨ ਦੇ ਸਜਾਵਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਤਿਆਰ ਕੀਤਾ ਹੈ। ਇਸ ਪਹੁੰਚ ਨੇ ਨਾ ਸਿਰਫ਼ ਕਿਸੇ ਵੀ ਵਧੇ ਹੋਏ ਅਪਵਾਦ ਨੂੰ ਹਾਸਲ ਕੀਤਾ, ਸਗੋਂ ਅੱਗੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਸੰਬੰਧਿਤ ਡੇਟਾ ਨੂੰ ਅੱਗੇ ਵੀ ਭੇਜ ਦਿੱਤਾ। ਮੈਨੂੰ ਤੁਹਾਡੇ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ, ਇਹਨਾਂ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਾਲੇ ਇੱਕ ਮਜ਼ਬੂਤ ​​​​ਗਲਤੀ-ਪ੍ਰਬੰਧਨ ਵਿਧੀ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਮਾਰਗਦਰਸ਼ਨ ਕਰਨ ਦਿਓ। 🚀

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
functools.wraps	ਇਹ ਸਜਾਵਟ ਕਰਨ ਵਾਲਿਆਂ ਵਿੱਚ ਮੂਲ ਫੰਕਸ਼ਨ ਦੇ ਮੈਟਾਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਸਦਾ ਨਾਮ ਅਤੇ ਡੌਕਸਟ੍ਰਿੰਗ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਰੈਪਰ ਫੰਕਸ਼ਨ ਮੂਲ ਗੁਣਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਨਹੀਂ ਕਰਦਾ ਹੈ।
json.loads	ਇੱਕ JSON ਸਟ੍ਰਿੰਗ ਨੂੰ ਇੱਕ Python ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, Azure ਫੰਕਸ਼ਨ ਵਿੱਚ ਆਉਣ ਵਾਲੇ ਇਵੈਂਟ ਸੁਨੇਹਿਆਂ ਨੂੰ ਡੀਸੀਰੀਅਲਾਈਜ਼ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
logging.error	ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਦੌਰਾਨ ਗਲਤੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਲੌਗ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਉਤਪਾਦਨ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਡੀਬੱਗਿੰਗ ਅਤੇ ਟਰੈਕਿੰਗ ਮੁੱਦਿਆਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।
raise Exception	ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇੱਕ ਅਪਵਾਦ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਮੂਲ ਅਪਵਾਦ ਸੰਦੇਸ਼ ਨੂੰ ਵਾਧੂ ਸੰਦਰਭ ਦੇ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਸਲ ਸੰਦੇਸ਼ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ।
async def	ਇੱਕ ਅਸਿੰਕਰੋਨਸ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਪਾਈਥਨ ਵਿੱਚ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਤੋਂ ਵੱਧ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਵਰਗੇ ਗੈਰ-ਬਲੌਕਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।
httpx.AsyncClient	ਅਸਿੰਕ੍ਰੋਨਸ HTTP ਬੇਨਤੀਆਂ ਕਰਨ ਲਈ ਇੱਕ ਖਾਸ HTTP ਕਲਾਇੰਟ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ Azure ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਾਹਰੀ APIs ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੇ ਸਮੇਂ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ।
@ErrorHandler	ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਅਤੇ ਸੰਦਰਭ ਧਾਰਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸਮੇਟਣ ਲਈ ਕਲਾਸ-ਅਧਾਰਿਤ ਹੱਲ ਵਿੱਚ ਇੱਕ ਸਜਾਵਟ ਕਰਨ ਵਾਲਾ।
middleware	ਇੱਕ ਕਸਟਮ ਮਿਡਲਵੇਅਰ ਫੰਕਸ਼ਨ ਕੇਂਦਰੀਕ੍ਰਿਤ ਢੰਗ ਨਾਲ ਮਲਟੀਪਲ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਲਈ ਅਪਵਾਦਾਂ ਅਤੇ ਲੌਗ ਸੁਨੇਹਿਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਲੇਅਰ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ।
asyncio.run	ਸਮਕਾਲੀ ਸੰਦਰਭ ਵਿੱਚ ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਅਸਿੰਕ ਵਿਧੀਆਂ ਦੀ ਆਸਾਨ ਜਾਂਚ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
KeyError	ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਉਭਾਰਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਲੋੜੀਂਦੀ ਕੁੰਜੀ ਗੁੰਮ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ JSON ਪੇਲੋਡ ਵਿੱਚ ਗੁੰਮ ਫੀਲਡ।

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਮਕੈਨਿਜ਼ਮ ਬਣਾਉਣਾ

ਪਾਈਥਨ ਵਿੱਚ, ਸਜਾਵਟ ਕਰਨ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਵਧਾਉਣ ਜਾਂ ਸੋਧਣ ਦਾ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਕੇਂਦਰੀਕ੍ਰਿਤ ਢੰਗ ਨਾਲ ਅਪਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਆਦਰਸ਼ ਬਣਾਉਂਦੇ ਹਨ। ਉਪਰੋਕਤ ਉਦਾਹਰਨਾਂ ਵਿੱਚ, ਡੈਕੋਰੇਟਰ ਅਪਵਾਦਾਂ ਨੂੰ ਰੋਕਣ ਲਈ ਟਾਰਗੇਟ ਫੰਕਸ਼ਨ ਨੂੰ ਲਪੇਟਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਅਪਵਾਦ ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਜਾਵਟ ਕਰਨ ਵਾਲਾ ਗਲਤੀ ਨੂੰ ਲੌਗ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸਲ ਸੰਦਰਭ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਆਉਣ ਵਾਲੇ ਇਵੈਂਟ ਸੰਦੇਸ਼। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਹਾਅ ਦੌਰਾਨ ਗਲਤੀ ਜਾਣਕਾਰੀ ਗੁੰਮ ਨਹੀਂ ਹੋਈ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ Azure ਫੰਕਸ਼ਨਾਂ ਵਰਗੀਆਂ ਸੇਵਾਵਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ, ਜਿੱਥੇ ਅਸਥਾਈ ਤਰੁਟੀਆਂ ਅਤੇ ਅਵੈਧ ਪੇਲੋਡਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਲਈ ਸੰਦਰਭ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। 🛠️

ਦੀ ਵਰਤੋਂ ਹੱਲ ਦਾ ਇੱਕ ਹੋਰ ਨਾਜ਼ੁਕ ਪਹਿਲੂ ਹੈ। 'async def' ਨਾਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਅਤੇ 'asyncio' ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਸਕ੍ਰਿਪਟਾਂ ਮੁੱਖ ਥ੍ਰੈੱਡ ਨੂੰ ਬਲੌਕ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕੋ ਸਮੇਂ ਕਈ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਦੀਆਂ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਇਵੈਂਟ ਹੱਬ ਤੋਂ ਸੁਨੇਹਿਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਪੇਲੋਡ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰ ਸਕਦੀ ਹੈ, API ਕਾਲਾਂ ਕਰ ਸਕਦੀ ਹੈ, ਅਤੇ ਇੱਕੋ ਸਮੇਂ ਲੌਗ ਗਲਤੀਆਂ ਕਰ ਸਕਦੀ ਹੈ। ਇਹ ਗੈਰ-ਬਲਾਕ ਕਰਨ ਵਾਲਾ ਵਿਵਹਾਰ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਮਾਪਯੋਗਤਾ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਉੱਚ-ਥਰੂਪੁੱਟ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਜਿੱਥੇ ਦੇਰੀ ਮਹਿੰਗੀ ਹੁੰਦੀ ਹੈ।

ਮਿਡਲਵੇਅਰ ਅਤੇ ਕਲਾਸ-ਆਧਾਰਿਤ ਡੈਕੋਰੇਟਰ ਹੱਲ ਲਚਕਤਾ ਦੀ ਇੱਕ ਵਾਧੂ ਪਰਤ ਲਿਆਉਂਦੇ ਹਨ। ਮਿਡਲਵੇਅਰ ਮਲਟੀਪਲ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਲਈ ਇੱਕ ਕੇਂਦਰੀਕ੍ਰਿਤ ਗਲਤੀ-ਪ੍ਰਬੰਧਨ ਲੇਅਰ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਕਸਾਰ ਲੌਗਿੰਗ ਅਤੇ ਅਪਵਾਦ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਦੌਰਾਨ, ਕਲਾਸ-ਅਧਾਰਿਤ ਡੈਕੋਰੇਟਰ ਕਿਸੇ ਵੀ ਫੰਕਸ਼ਨ ਨੂੰ ਸਮੇਟਣ ਲਈ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਢਾਂਚਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਕਸਟਮ ਐਰਰ-ਹੈਂਡਲਿੰਗ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, JSON ਸੁਨੇਹਿਆਂ ਦੇ ਇੱਕ ਬੈਚ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਦੇ ਸਮੇਂ, ਮਿਡਲਵੇਅਰ ਹਰੇਕ ਸੁਨੇਹੇ ਲਈ ਮੁੱਦਿਆਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਲੌਗ ਕਰ ਸਕਦਾ ਹੈ ਜਦੋਂ ਕਿ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇੱਕ ਗਲਤੀ ਨਾਲ ਰੋਕਿਆ ਨਹੀਂ ਗਿਆ ਹੈ। 🚀

ਅੰਤ ਵਿੱਚ, ਹੱਲ ਪਾਈਥਨ ਦੀਆਂ ਉੱਨਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਅਸਿੰਕ੍ਰੋਨਸ HTTP ਬੇਨਤੀਆਂ ਲਈ। ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਬਾਹਰੀ API, ਜਿਵੇਂ ਕਿ ਪਹੁੰਚ ਪ੍ਰਬੰਧਕਾਂ ਨਾਲ ਕੁਸ਼ਲਤਾ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ। ਇਹਨਾਂ API ਕਾਲਾਂ ਨੂੰ ਸਜਾਵਟ ਵਿੱਚ ਲਪੇਟਣ ਨਾਲ, ਕੋਈ ਵੀ HTTP-ਸਬੰਧਤ ਤਰੁੱਟੀਆਂ ਨੂੰ ਕੈਪਚਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਲੌਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅਸਲ ਸੁਨੇਹੇ ਦੇ ਨਾਲ ਦੁਬਾਰਾ ਉਭਾਰਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਭਾਵੇਂ ਕੋਈ ਬਾਹਰੀ ਸੇਵਾ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਸਿਸਟਮ ਇਸ ਬਾਰੇ ਪਾਰਦਰਸ਼ਤਾ ਬਣਾਈ ਰੱਖਦਾ ਹੈ ਕਿ ਕੀ ਗਲਤ ਹੋਇਆ ਅਤੇ ਕਿਉਂ। ਇਹ ਤਕਨੀਕਾਂ, ਮਿਲਾ ਕੇ, ਪਾਈਥਨ ਵਿੱਚ ਮਜ਼ਬੂਤ ​​ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਲਈ ਇੱਕ ਵਿਆਪਕ ਫਰੇਮਵਰਕ ਬਣਾਉਂਦੀਆਂ ਹਨ।

import functools
import logging
# Define a custom decorator for error handling
def error_handler_decorator(func):
    @functools.wraps(func)
    async def wrapper(*args, kwargs):
        original_message = kwargs.get("eventHubMessage", "Unknown message")
        try:
            return await func(*args, kwargs)
        except Exception as e:
            logging.error(f"Error: {e}. Original message: {original_message}")
            # Re-raise with combined context
            raise Exception(f"{e} | Original message: {original_message}")
    return wrapper
# Example usage
@error_handler_decorator
async def main(eventHubMessage):
    data = json.loads(eventHubMessage)
    logging.info(f"Processing data: {data}")
    # Simulate potential error
    if not data.get("RequestID"):
        raise ValueError("Missing RequestID")
    # Simulate successful processing
    return "Processed successfully"
# Test
try:
    import asyncio
    asyncio.run(main(eventHubMessage='{"ProductType": "Test"}'))
except Exception as e:
    print(f"Caught exception: {e}")

import logging
# Define a class-based decorator
class ErrorHandler:
    def __init__(self, func):
        self.func = func
    async def __call__(self, *args, kwargs):
        original_message = kwargs.get("eventHubMessage", "Unknown message")
        try:
            return await self.func(*args, kwargs)
        except Exception as e:
            logging.error(f"Error: {e}. Original message: {original_message}")
            raise Exception(f"{e} | Original message: {original_message}")
# Example usage
@ErrorHandler
async def process_event(eventHubMessage):
    data = json.loads(eventHubMessage)
    logging.info(f"Data: {data}")
    if "RequestType" not in data:
        raise KeyError("Missing RequestType")
    return "Event processed!"
# Test
try:
    import asyncio
    asyncio.run(process_event(eventHubMessage='{"RequestID": "123"}'))
except Exception as e:
    print(f"Caught exception: {e}")

import logging
async def middleware(handler, message):
    try:
        return await handler(message)
    except Exception as e:
        logging.error(f"Middleware caught error: {e} | Message: {message}")
        raise
# Handlers
async def handler_one(message):
    if not message.get("ProductType"):
        raise ValueError("Missing ProductType")
    return "Handler one processed."
# Test middleware
message = {"RequestID": "123"}
try:
    import asyncio
    asyncio.run(middleware(handler_one, message))
except Exception as e:
    print(f"Middleware exception: {e}")

ਵਿਤਰਿਤ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਨੂੰ ਵਧਾਉਣਾ

ਜਦੋਂ ਡਿਸਟ੍ਰੀਬਿਊਟਿਡ ਸਿਸਟਮਾਂ ਨਾਲ ਨਜਿੱਠਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਈਵੈਂਟ ਹੱਬ ਵਿਸ਼ਿਆਂ ਨੂੰ ਸੁਣਨਾ Azure ਫੰਕਸ਼ਨ, ਮਜ਼ਬੂਤ ​​ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਸਿਸਟਮ ਭਰੋਸੇਯੋਗਤਾ ਦਾ ਆਧਾਰ ਬਣ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਜੋ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਹੈ ਅਪਵਾਦਾਂ ਨੂੰ ਉਸ ਮੂਲ ਸੰਦਰਭ ਦੇ ਨਾਲ ਟਰੈਕ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਜੋੜਨ ਦੀ ਯੋਗਤਾ ਜਿਸ ਵਿੱਚ ਉਹ ਵਾਪਰੇ ਸਨ। ਇਸ ਸੰਦਰਭ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾ ਰਹੀ ਪੇਲੋਡ ਅਤੇ ਟਾਈਮਸਟੈਂਪ ਜਾਂ ਪਛਾਣਕਰਤਾ ਵਰਗੇ ਮੈਟਾਡੇਟਾ ਸ਼ਾਮਲ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਨੁਕਸਦਾਰ JSON ਪੇਲੋਡ ਨਾਲ ਇੱਕ ਇਵੈਂਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰੋ। ਸਹੀ ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਦੇ ਬਿਨਾਂ, ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਇੱਕ ਡਰਾਉਣਾ ਸੁਪਨਾ ਬਣ ਸਕਦਾ ਹੈ। ਮੂਲ ਸੰਦੇਸ਼ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖ ਕੇ ਅਤੇ ਇਸਨੂੰ ਗਲਤੀ ਲੌਗ ਨਾਲ ਜੋੜ ਕੇ, ਅਸੀਂ ਇੱਕ ਪਾਰਦਰਸ਼ੀ ਅਤੇ ਕੁਸ਼ਲ ਡੀਬਗਿੰਗ ਵਰਕਫਲੋ ਬਣਾਉਂਦੇ ਹਾਂ। 🛠️

ਇੱਕ ਹੋਰ ਮੁੱਖ ਵਿਚਾਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਅਸਥਾਈ ਗਲਤੀਆਂ ਦੇ ਬਾਵਜੂਦ ਸਿਸਟਮ ਲਚਕੀਲਾ ਬਣਿਆ ਰਹਿੰਦਾ ਹੈ। ਅਸਥਾਈ ਤਰੁਟੀਆਂ, ਜਿਵੇਂ ਕਿ ਨੈੱਟਵਰਕ ਟਾਈਮਆਉਟ ਜਾਂ ਸੇਵਾ ਦੀ ਅਣਉਪਲਬਧਤਾ, ਕਲਾਉਡ ਵਾਤਾਵਰਨ ਵਿੱਚ ਆਮ ਹਨ। ਕੇਂਦਰੀਕ੍ਰਿਤ ਗਲਤੀ ਲੌਗਿੰਗ ਲਈ ਸਜਾਵਟ ਕਰਨ ਵਾਲਿਆਂ ਦੇ ਨਾਲ, ਘਾਤਕ ਬੈਕਆਫ ਦੇ ਨਾਲ ਮੁੜ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ, ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ ਵਿੱਚ ਬਹੁਤ ਸੁਧਾਰ ਕਰ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲਾਇਬ੍ਰੇਰੀਆਂ ਪਸੰਦ ਹਨ ਅਸਿੰਕਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਬਾਹਰੀ API ਕਾਲਾਂ ਲਈ ਗੈਰ-ਬਲੌਕ ਕਰਨ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਸਥਾਈ ਰੁਕਾਵਟਾਂ ਇਵੈਂਟ ਪ੍ਰੋਸੈਸਿੰਗ ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਕੁੱਲ ਅਸਫਲਤਾਵਾਂ ਵੱਲ ਅਗਵਾਈ ਨਹੀਂ ਕਰਦੀਆਂ ਹਨ।

ਅੰਤ ਵਿੱਚ, ਢਾਂਚਾਗਤ ਲੌਗਿੰਗ ਫਾਰਮੈਟਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ, ਜਿਵੇਂ ਕਿ JSON ਲੌਗਸ, ਤਰੁੱਟੀਆਂ ਦੀ ਦਿੱਖ ਅਤੇ ਖੋਜਯੋਗਤਾ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਾ ਸਕਦੇ ਹਨ। ਲੌਗਸ ਵਿੱਚ ਖੇਤਰ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਅਪਵਾਦ ਕਿਸਮ, ਅਸਲ ਸੁਨੇਹਾ, ਅਤੇ ਇੱਕ ਟਾਈਮਸਟੈਂਪ। ਇਹ ਢਾਂਚਾਗਤ ਲੌਗ ਰੀਅਲ-ਟਾਈਮ ਨਿਗਰਾਨੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਕੇਂਦਰੀਕ੍ਰਿਤ ਲੌਗਿੰਗ ਪ੍ਰਣਾਲੀਆਂ, ਜਿਵੇਂ ਕਿ Azure ਮਾਨੀਟਰ ਜਾਂ Elasticsearch ਨੂੰ ਅੱਗੇ ਭੇਜਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਵਿਕਾਸ ਟੀਮਾਂ ਪੈਟਰਨਾਂ ਦੀ ਤੇਜ਼ੀ ਨਾਲ ਪਛਾਣ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਖਾਸ ਪੇਲੋਡਾਂ ਨਾਲ ਆਵਰਤੀ ਗਲਤੀਆਂ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਰਗਰਮੀ ਨਾਲ ਹੱਲ ਕਰ ਸਕਦੀਆਂ ਹਨ। 🚀

1. ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਲਈ ਡੈਕੋਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕੀ ਮਕਸਦ ਹੈ?
2. ਇੱਕ ਸਜਾਵਟ, ਜਿਵੇਂ ਕਿ , ਕਈ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਗਲਤੀ ਲੌਗਿੰਗ ਅਤੇ ਹੈਂਡਲਿੰਗ ਨੂੰ ਕੇਂਦਰਿਤ ਕਰਦਾ ਹੈ। ਇਹ ਅਪਵਾਦਾਂ ਦੀ ਇਕਸਾਰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਮੂਲ ਸੰਦੇਸ਼ ਵਰਗੇ ਮਹੱਤਵਪੂਰਨ ਸੰਦਰਭ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ।
3. ਕਿਵੇਂ ਕਰਦਾ ਹੈ API ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ ਹੈ?
4. ਇਹ ਅਸਿੰਕ੍ਰੋਨਸ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਈ API ਕਾਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲਦੀ ਹੈ, ਜੋ ਕਿ Azure ਫੰਕਸ਼ਨ ਵਰਗੇ ਉੱਚ-ਥਰੂਪੁੱਟ ਸਿਸਟਮਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।
5. ਢਾਂਚਾਗਤ ਲੌਗਿੰਗ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ?
6. ਸਟ੍ਰਕਚਰਡ ਲੌਗਿੰਗ ਫਾਰਮੈਟ, ਜਿਵੇਂ ਕਿ JSON ਲੌਗ, Azure Monitor ਜਾਂ Splunk ਵਰਗੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਗਲਤੀਆਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਨਿਗਰਾਨੀ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ।
7. ਅਸਥਾਈ ਗਲਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ?
8. ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਲਈ ਇੱਕ ਸਜਾਵਟ ਦੇ ਨਾਲ, ਘਾਤਕ ਬੈਕਆਫ ਦੇ ਨਾਲ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨਾ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਸਥਾਈ ਮੁੱਦੇ ਸਥਾਈ ਤਰੁਟੀਆਂ ਵੱਲ ਅਗਵਾਈ ਨਹੀਂ ਕਰਦੇ ਹਨ।
9. ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਮੂਲ ਸੰਦਰਭ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ?
10. ਅਸਲ ਸੁਨੇਹੇ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ, ਜਿਵੇਂ ਕਿ ਪੇਲੋਡ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ, ਡੀਬੱਗਿੰਗ ਅਤੇ ਟਰੇਸਿੰਗ ਮੁੱਦਿਆਂ ਲਈ ਅਨਮੋਲ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਵਿਤਰਿਤ ਸਿਸਟਮਾਂ ਵਿੱਚ।

ਡਿਸਟਰੀਬਿਊਟਿਡ ਸਿਸਟਮਾਂ ਵਿੱਚ ਅਪਵਾਦ ਹੈਂਡਲਿੰਗ, ਜਿਵੇਂ ਕਿ Azure ਫੰਕਸ਼ਨ, ਨਿਰਵਿਘਨ ਕਾਰਵਾਈਆਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇੱਕ ਸਜਾਵਟ ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਸਮੇਟ ਕੇ ਅਤੇ ਮੂਲ ਸੰਦਰਭ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖ ਕੇ, ਡਿਵੈਲਪਰ ਡੀਬੱਗਿੰਗ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ ਸਿਸਟਮ ਪਾਰਦਰਸ਼ਤਾ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਂਦੇ ਹਨ। ਇਹ ਪਹੁੰਚ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਗਤੀਸ਼ੀਲ, ਅਸਲ-ਸੰਸਾਰ ਦੇ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਮਦਦਗਾਰ ਹੈ ਜਿੱਥੇ ਮੁੱਦੇ ਅਟੱਲ ਹਨ।

ਅਸਿੰਕ੍ਰੋਨਸ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਅਤੇ ਸਟ੍ਰਕਚਰਡ ਲੌਗਿੰਗ ਵਰਗੀਆਂ ਉੱਨਤ ਤਕਨੀਕਾਂ ਨੂੰ ਜੋੜ ਕੇ, ਪਾਈਥਨ ਲਚਕੀਲੇ ਸਿਸਟਮਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੰਦ ਬਣ ਜਾਂਦਾ ਹੈ। ਇਹ ਹੱਲ ਸਮੱਸਿਆ ਨਿਪਟਾਰੇ ਦੌਰਾਨ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰਦੇ ਹਨ ਅਤੇ ਅਸਥਾਈ ਗਲਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹੱਲ ਕਰਕੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦੇ ਹਨ। ਇਹਨਾਂ ਅਭਿਆਸਾਂ ਨੂੰ ਅਪਣਾਉਣ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਮਜਬੂਤ ਅਤੇ ਸਕੇਲੇਬਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਸ਼ਕਤੀ ਮਿਲਦੀ ਹੈ, ਰੋਜ਼ਾਨਾ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪ੍ਰਬੰਧਨਯੋਗ ਬਣਾਉਂਦੇ ਹੋਏ। 🛠️