Sentry-javascript: [@ संतरी/नोड] एडब्ल्यूएस लैम्ब्डा और अन्य सर्वर रहित समाधान समर्थन

यह मुझे अनुमान लगाने में मदद कर सकता है https://blog.sentry.io/2018/06/20/how-droplr-uses-sentry-to-debug-serverless (यह पुराने रेवेन संस्करण का उपयोग कर रहा है, जिसमें कॉलबैक था, लेकिन मैं हूं ज्यादातर एक callbackWaitsForEmptyEventLoop ध्वज की ओर इशारा करते हैं।

अभी तक कोई आधिकारिक तरीका नहीं है , क्योंकि हम अभी भी बीटा में चीजों को आजमा रहे हैं, लेकिन यह इस कोड के साथ करने योग्य है:

import { init, getDefaultHub } from '@sentry/node';

init({
  dsn: 'https://my-dsn.com/1337'
});

exports.myHandler = async function(event, context) {
  // your code

  await getDefaultHub().getClient().captureException(error, getDefaultHub().getScope());
  context.fail();
}

@kamilogorek सूचक के लिए धन्यवाद। मैं इसे आज़मा दूंगा और सीखों को वापस खेलूंगा।

@kamilogorek आप सुझाव काम करते हैं। मैं एक अधिक आधिकारिक तरीके की प्रतीक्षा कर रहा हूं।

@vietbui
4.0.0-rc.1 में हमने क्लाइंट पर close नामक एक फ़ंक्शन पेश किया, आप इसे इस तरह कहते हैं:

import { getCurrentHub } from '@sentry/node';

getCurrentHub().getClient().close(2000).then(result => {
      if (!result) {
        console.log('We reached the timeout for emptying the request buffer, still exiting now!');
      }
      global.process.exit(1);
})

close सभी अनुरोध भेजे जाने तक प्रतीक्षा करेगा, यह हमेशा हल हो जाएगा (परिणाम = झूठा समय समाप्त हो गया था), जब तक समय समाप्त नहीं हो जाता (इस उदाहरण में 2000ms)।
यह हमारा आधिकारिक एपीआई है।
जबकि पिछला दृष्टिकोण अभी भी काम करेगा, close विधि सभी मामलों के लिए काम करती है।

@HazAT अच्छा लगा। सारी कड़ी मेहनत के लिए शुक्रिया।

4.0.3 में मैं इसे अपने लैम्ब्डा फ़ंक्शन में इस तरह कहता हूं:

try {
  ...
} catch (err) {
  await getCurrentHub().getClient().captureException(err, getCurrentHub().getScope())
  throw err
}

getDefaultHub() अब उपलब्ध नहीं है।

@vietbui इसे अब getCurrentHub कहा जाता है, क्योंकि हमें अपने एपीआई को अन्य भाषाओं के एसडीके के साथ एकीकृत करना था।

@kamilogorek स्पष्टीकरण के लिए धन्यवाद। getCurrentHub दृष्टिकोण के साथ एक समस्या है क्योंकि किसी तरह मैंने जो दायरा स्थापित किया है वह संतरी में समाप्त नहीं हुआ।

अंत में मैंने अपने लैम्ब्डा कार्यों में अपवाद को पकड़ने के लिए @HazAT द्वारा सुझाए गए अनुसार एक अलग दृष्टिकोण लिया:

try {
  ...
} catch (err) {
  Sentry.captureException(err)
  await new Promise(resolve => Sentry.getCurrentHub().getClient().close(2000).then(resolve))
  throw err
}

और यह पूरी तरह से काम करता है।

क्या घटनाओं को भेजने के लिए संतरी को प्रतीक्षा/मजबूर करने का यह अनुशंसित तरीका है?

@albinekb हाँ - https://docs.sentry.io/learn/draining/?platform=browser

@albinekb हाँ - https://docs.sentry.io/learn/draining/?platform=browser

यह समाधान किसी कारण से मेरे लिए काम नहीं करता है। यह केवल पहली बार उत्पादन में काम करता है जब ठंड शुरू होने का समय होता है और उसके बाद काम नहीं करता है। यहाँ उदाहरण कोड है

'use strict'

const Sentry =  require('@sentry/node')
Sentry.init({
  dsn: 'xxx',
  environment: process.env.STAGE
});

module.exports.createPlaylist = async (event, context, callback) => {
  context.callbackWaitsForEmptyEventLoop = false
  if(!event.body) {
    Sentry.captureException(error)
    await new Promise(resolve => Sentry.getCurrentHub().getClient().close(2000).then(resolve))
    return {
      statusCode: 500,
      headers: { 'Content-Type': 'text/plain' },
      body: 'Missing body parameters'
    }
  }
  return {
    statusCode: 200,
  }
};

@ एंड्री-कुलक ने दस्तावेज़ों में भी कहा है:

After shutdown the client cannot be used any more so make sure to only do that right before you shut down the application.

तो मुझे नहीं पता कि हम इसे लैम्ब्डा में कैसे संभाल सकते हैं जहां हम नहीं जानते कि आवेदन कब मारा जाएगा। प्रति अनुरोध संतरी को निकालना सबसे अच्छा होगा जैसे हम पुराने एपीआई के साथ कर सकते थे?

@HazAT क्या हम इसे फिर से खोल सकते हैं? मुझे लगता है कि लैम्ब्डा पर इसके साथ काम करने का एक तरीका होना महत्वपूर्ण है, जो कि तैनाती के लिए एक आम लक्ष्य बनता जा रहा है।

यह वर्तमान में मुझे नवीनतम संस्करण में अपग्रेड करने से रोक रहा है...

व्यक्तिगत रूप से, मैं किसी त्रुटि की रिपोर्ट करते समय एक वादा/कॉलबैक प्राप्त करने में सक्षम होना पसंद करूंगा। कतार को वास्तव में बाद में बंद किए बिना निकालने का एक तरीका होना अगली सबसे अच्छी बात होगी ...

कॉलबैक को captureException से हटाने का औचित्य क्या था?

@albinekb अगर मैं निम्नलिखित पंक्ति को हटाता हूं तो यह बिल्कुल भी काम नहीं करता है

await new Promise(resolve => Sentry.getCurrentHub().getClient().close(2000).then(resolve))

@LinusU क्या समाधान है और संतरी या रेवेन समाधान क्या आप उपयोग कर रहे हैं?

मेरे लिए मूल रूप से निम्नलिखित काम करता है sentry/node @4.3.0 , लेकिन मुझे लैम्ब्डा को कुछ समय के लिए मैन्युअल रूप से प्रतीक्षा करनी होगी (इस मामले में मैं 2 सेकंड लगाता हूं) संतरी को वह करने के लिए जो उसे करने की आवश्यकता है। जो मुझे यकीन नहीं है कि इसे वहां क्यों होना चाहिए क्योंकि हम captureException अनुरोध को पूरा करने के लिए संतरी की प्रतीक्षा कर रहे हैं। अगर मेरे पास बाद में प्रतीक्षा अवधि नहीं है, तो संतरी त्रुटि भेजने के लिए प्रतीत नहीं होता है।

'use strict'

const Sentry =  require('@sentry/node')
Sentry.init({
  dsn: 'xxx',
  environment: process.env.STAGE
});

module.exports.createPlaylist = async (event, context, callback) => {
  context.callbackWaitsForEmptyEventLoop = false
  if(!event.body) {
    const error = new Error('Missing body parameters in createPlaylist')
    await Sentry.captureException(error)
    await new Promise(resolve => {setTimeout(resolve, 2000)})
    return {
      statusCode: 500,
      headers: { 'Content-Type': 'text/plain' },
      body: 'Missing body parameters'
    }
  }
  return {
    statusCode: 200,
  }
};

हम लैम्ब्डा पर भी इस पर जल रहे हैं। हमने नए कामों के साथ शुरुआत की और रेवेन पर वापस जाने पर विचार करते हुए पूरी तरह से बॉक्सिंग आउट हो गए। हब को बंद करने और फिर से शुरू करने के प्रयास के लिए हम अभी परीक्षण लिख रहे हैं, जो पानी रखने पर एक व्यावहारिक समाधान होगा। लेकिन अभी भी हैकी/लोड के तहत समस्याएं पैदा करने की संभावना है।

व्यक्तिगत रूप से मैं किसी प्रकार का flush() पसंद करूंगा जो एक वादा लौटाता है - एक नकारात्मक पक्ष खोजना मुश्किल है। सोचो ऐसा कभी होगा?

समाधान क्या है और संतरी या रेवेन समाधान आप उपयोग कर रहे हैं?

मैं निम्नलिखित एक्सप्रेस त्रुटि हैंडलर का उपयोग कर रहा हूं:

app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  let status = (err.status || err.statusCode || 500) as number

  if (process.env.NODE_ENV === 'test') {
    return next(err)
  }

  if (status < 400 || status >= 500) {
    Raven.captureException(err, () => next(err))
  } else {
    next(err)
  }
})

मैं तब लैम्ब्डा में एक्सप्रेस ऐप को तैनात करने के लिए स्कैंडियम का उपयोग कर रहा हूं

संपादित करें: यह रेवेन के साथ है "raven": "^2.6.3",

ड्रीम एपीआई कुछ इस तरह होगा

Sentry.captureException(err: Error): Promise<void>

@LinusU https://github.com/getsentry/sentry-javascript/blob/master/packages/core/src/baseclient.ts#L145 -L152

हालांकि इसे प्राप्त करने के लिए आपको सीधे क्लाइंट इंस्टेंस का उपयोग करना होगा। इसका कारण यह है कि यह तय किया गया है कि मुख्य परिदृश्य "आग और भूल" प्रकार का व्यवहार है, इस प्रकार यह एक एसिंक विधि नहीं है। आंतरिक रूप से हालांकि, हमारे पास एसिंक एपीआई है जिसका हम स्वयं उपयोग करते हैं।

ऐसा लगता है कि मैं वास्तव में जो चाहता हूं वह कुछ और है:

const backend = client.getBackend()
const event = await backend.eventFromException(error)
await client.processEvent(event, finalEvent => backend.sendEvent(finalEvent))

सभी कतारबद्ध और बफ़रिंग को छोड़ने के लिए...

मुझे लगता है कि डिजाइन "आग और भूल" के अनुरूप है, और लंबे समय तक चलने वाले सर्वर में चलने के लिए, और यह शायद उस पर काफी अच्छा है क्योंकि यह बहुत अधिक बफरिंग करता है। समस्या यह है कि यह बिल्कुल विपरीत है कि आप लैम्ब्डा, ऐप इंजन और अन्य "सर्वर रहित" आर्किटेक्चर के लिए चाहते हैं, जो अधिक से अधिक सामान्य होते जा रहे हैं।

क्या यह संभव होगा कि एक विशेष विधि हो जो घटना को जितनी जल्दी हो सके भेज दे, और एक Promise लौटाए जिसे हम await कर सकें? यह सर्वर रहित परिदृश्यों के लिए एकदम सही होगा!

class Sentry {
  // ...

  async unbufferedCaptureException(err: Error): Promise<void> {
    const backend = this.client.getBackend()
    const event = await backend.eventFromException(error)
    await this.client.processEvent(event, finalEvent => backend.sendEvent(finalEvent))
  }

  // ...
}

@LinusU हम इस परिदृश्य के लिए एक विशिष्ट सर्वर रहित पैकेज बनाने की संभावना रखते हैं। हमें बस कुछ समय निकालने की जरूरत है, क्योंकि यह साल का अंत है और चीजें अब भीड़भाड़ वाली हो रही हैं। आपको सूचित किया जाता रहेगा!

हम इस परिदृश्य के लिए एक विशिष्ट सर्वर रहित पैकेज बनाने की संभावना रखते हैं

वह अद्भुत होगा! मैं

@mtford90

मैं वास्तव में इस बेहतर समाधान का उपयोग कब करूंगा? जहां तक ​​​​मुझे पता है कि यह जानना संभव नहीं है कि लैम्ब्डा कब बंद हो जाएगा - साथ ही संतरी को अपनी बात करने की अनुमति देने के लिए शटडाउन के लिए मनमाने ढंग से समय की प्रतीक्षा करना मूर्खतापूर्ण लगता है - विशेष रूप से महंगी उच्च मेमोरी/सीपीयू लैम्ब्डा फ़ंक्शंस पर।

(जल निकासी के बारे में बात कर रहे हैं)

यह सर्वर प्रक्रिया को बंद करने से पहले आखिरी चीज के रूप में उपयोग करने के लिए है। drain पद्धति में समयबाह्य वह अधिकतम समय है जिसका हम प्रक्रिया को बंद करने से पहले प्रतीक्षा करेंगे, जिसका अर्थ यह नहीं है कि हम हमेशा उस समय का उपयोग करेंगे। यदि सर्वर पूरी तरह से प्रतिक्रियाशील है, तो यह शेष सभी ईवेंट को तुरंत भेज देगा।

इसे प्रति से जानने का कोई तरीका नहीं है, लेकिन लैम्ब्डा को यह बताने का एक तरीका है कि इसे हैंडलर के कॉलबैक तर्क का उपयोग करके कब बंद किया जाना चाहिए।

इसके अलावा @LinusU , मैंने आपकी पिछली टिप्पणी, विशेष रूप से इस भाग को फिर से पढ़ा:

क्या यह संभव होगा कि एक विशेष विधि हो जो घटना को जितनी जल्दी हो सके भेज दे, और एक वादा लौटाए जिसका हम इंतजार कर सकते हैं? यह सर्वर रहित परिदृश्यों के लिए एकदम सही होगा!

इस तरह हमने अपने बफर को लागू किया। क्लाइंट पर प्रत्येक captureX कॉल, इसे बफर में जोड़ देगा, यह सही है, लेकिन यह किसी भी तरह से कतारबद्ध नहीं है, इसे तुरंत निष्पादित किया जाता है और इस पैटर्न का उपयोग केवल इसलिए किया जाता है ताकि हम जानकारी प्राप्त कर सकें यदि सब कुछ था संतरी के माध्यम से सफलतापूर्वक भेजा गया।

https://github.com/getsentry/sentry-javascript/blob/0f0dc37a4276aa2b832da451307bc4cd5413b34d/packages/core/src/requestbuffer.ts#L12 -L18

इसका मतलब यह है कि यदि आप AWS लैम्ब्डा में ऐसा कुछ करते हैं (यह मानते हुए कि आप डिफ़ॉल्ट क्लाइंट का उपयोग करना चाहते हैं, जो कि सबसे सरल मामला है):

import * as Sentry from '@sentry/browser';

Sentry.init({ dsn: '__YOUR_DSN__' });

exports.handler = (event, context, callback) => {
    try {
      // do something
    catch (err) {
      Sentry.getCurrentHub()
        .getClient()
        .captureException(err)
        .then((status) => {
          // request status
          callback(null, 'Hello from Lambda');
        })
    }
};

आप सुनिश्चित हो सकते हैं कि इसे तुरंत भेज दिया गया था और कोई समय/प्रसंस्करण ओवरहेड नहीं था।

@ कामिलोगोरेक
क्या इसका मतलब यह है कि ऐसा कुछ एसिंक/प्रतीक्षा हैंडलर में काम करना चाहिए (जहां आप कॉलबैक का उपयोग नहीं करते हैं)?

import * as Sentry from '@sentry/node';

Sentry.init({ dsn: '__YOUR_DSN__' });

exports.handler = async (event, context) => {
    try {
      // do something

      return 'Hello from Lambda';
    catch (err) {
      await Sentry.getCurrentHub().getClient().captureException(err);
      return 'Hello from Lambda with error';
    }
};

@jviolas पूरी तरह से! :)

ऐसा लगता है कि निम्नलिखित परिवर्तन मेरे लिए काम करेंगे तो ☺️

-import Raven = require('raven')
+import * as Sentry from '@sentry/node'

 // ...

-Raven.config(config.SENTRY_DSN)
+Sentry.init({ dsn: config.SENTRY_DSN })

 // ...

 app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
   let status = (err.status || err.statusCode || 500) as number

   if (process.env.NODE_ENV === 'test') {
     return next(err)
   }

   if (status < 400 || status >= 500) {
-    Raven.captureException(err, () => next(err))
+    Sentry.getCurrentHub().getClient().captureException(err).then(() => next(err))
   } else {
     next(err)
   }
 })

सच कहूं, तो हर लाइन थोड़ी बदसूरत हो गई 😆 लेकिन मुझे लगता है कि यह हुड के नीचे बेहतर है ...

@kamilogorek मुझे आपकी वेबसाइट पर दस्तावेज़ों में getCurrentHub() नहीं मिला, क्या यह एपीआई गारंटी है कि बिना किसी बड़े सेमर टक्कर के टूटने की गारंटी है? ❤️

@kamilogorek मुझे आपकी वेबसाइट पर दस्तावेज़ों में getCurrentHub() नहीं मिला, क्या यह एपीआई गारंटी है कि बिना किसी बड़े सेमर टक्कर के टूटने की गारंटी नहीं है? ❤️

हाँ, इसकी गारंटी है। यह @sentry/hub पैकेज का हिस्सा है जिसका वर्णन यहां किया गया है - https://docs.sentry.io/enriching-error-data/scopes/?platform=browser

हम यहां इस सूत्र में थोड़े "उन्नत उपयोगों" पर चर्चा कर रहे हैं और हम अभी तक उन्हें दस्तावेज करने के बिंदु पर नहीं पहुंचे हैं। हम इसे अंततः करेंगे :)

स्पष्ट रूप से हम यहां जो कुछ खो रहे हैं वह है इस तरह के उन्नत उपयोग के मामलों में कुछ दस्तावेज और अच्छा अभ्यास। यह वास्तव में अच्छा होगा जब इसे प्रलेखित किया जाएगा या यहां तक ​​कि एक ब्लॉग पोस्ट भी एक अच्छी शुरुआत हो सकती है।
अन्यथा, नया एसडीके वास्तव में उपयोग में आसान है और एकीकरण वास्तव में अच्छा है।

@ कामिलोगोरेक
क्या इसका मतलब यह है कि ऐसा कुछ एसिंक/प्रतीक्षा हैंडलर में काम करना चाहिए (जहां आप कॉलबैक का उपयोग नहीं करते हैं)?

import * as Sentry from '@sentry/node';

Sentry.init({ dsn: '__YOUR_DSN__' });

exports.handler = async (event, context) => {
    try {
      // do something

      return 'Hello from Lambda';
    catch (err) {
      await Sentry.getCurrentHub().getClient().captureException(err);
      return 'Hello from Lambda with error';
    }
};

जैसा कि ऊपर बताया गया है कुछ करना काम करता है, सिवाय इसके कि मैं अतिरिक्त संदर्भ जोड़ने में असमर्थ हूं। उदाहरण के लिए, यदि मैं करता हूं:

Sentry.configureScope(scope => {
   scope.setExtra('someExtraInformation', information);
});
await Sentry.getCurrentHub().getClient().captureException(err);

मैं वास्तव में संतरी में 'someExtraInformation' नहीं देखूंगा।

किसी ने इस धागे के शीर्ष पर एक वैकल्पिक विधि का सुझाव दिया था, और यह काम करता है, लेकिन हैकी लगता है (एक टाइमआउट को मजबूर करना)।

Sentry.configureScope(scope => {
  scope.setExtra('someExtraInformation', information);
});
Sentry.captureException(error);
await new Promise(resolve => Sentry.getCurrentHub().getClient().close(2000).then(resolve));

@kamilogorek @jviolas

import * as Sentry from '@sentry/node';

Sentry.init({ dsn: '__YOUR_DSN__' });

exports.handler = async (event, context) => {
   try {
     // do something

     return 'Hello from Lambda';
   catch (err) {
     await Sentry.getCurrentHub().getClient().captureException(err);
     return 'Hello from Lambda with error';
   }
};

क्या इसे _अनकॉटेड अपवाद_ पर भी लागू किया जा सकता है? ऐसा लगता है कि Sentry.Integrations.OnUncaughtException एकीकरण को संशोधित करना ऐसा करने का आधिकारिक तरीका है लेकिन दस्तावेज़ीकरण अभी बहुत खराब है।

इसके लिए +1। कम से कम आधिकारिक तौर पर कुछ प्रलेखित होना अच्छा होगा। 2019 तक सर्वर रहित तेजी से बढ़ रहा है, मैं वास्तव में इस पर संतरी से आधिकारिक समर्थन देखना चाहता हूं। जिन विचारों को मैंने यहां पढ़ा और वास्तव में पसंद किया उनमें से एक यह था कि कतारबद्ध सभी घटनाओं को भेजने के लिए Sentry.flush() जैसा कुछ होना चाहिए।

@rdsedmundo क्या आप विस्तार से बता सकते हैं कि यह दृष्टिकोण आपके लिए काम क्यों नहीं कर रहा है?

import * as Sentry from '@sentry/node';

Sentry.getCurrentHub().getClient().close(2000).then(result => {
      if (!result) {
        console.log('We reached the timeout for emptying the request buffer, still exiting now!');
      }
      global.process.exit(1);
})

यह हमारा आधिकारिक दृष्टिकोण है और मूल रूप से Sentry.flush() है।
संदर्भ: https://docs.sentry.io/error-reporting/configuration/draining/?platform=javascript

@HazAT इसके साथ समस्या तब आती है जब आप AWS लैम्ब्डा कंटेनर के पुन: उपयोग के बारे में सोचते हैं। जो टीएल; डीआर शब्दों में इसका मतलब है कि एक प्रक्रिया जिसने अभी-अभी अनुरोध किया है, वह एक नए ब्रांड की सेवा कर सकती है यदि यह समय की एक छोटी खिड़की पर बनाई गई हो। अगर मैं आपके द्वारा दिए गए इस स्निपेट के साथ कनेक्शन बंद कर दूं, और कंटेनर का पुन: उपयोग किया जाए, तो मुझे नए अनुरोध के लिए एक नया हब बनाने का प्रबंधन करना होगा। मैं इसे आसानी से मुश्किल होते देख सकता हूं। इसलिए एक साधारण await Sentry.flush() एक बेहतर उपाय होगा:

import Sentry from './sentry'; // this calls Sentry.init under the hood

export const handler = async (event, context) => {
  try {
    ...
  } catch (error) {
    Sentry.captureException(error);
    await Sentry.flush(); // could even be called on the finally block

    return formatError(error);
  }
}

@rdsedmundo मुझे यकीन नहीं है कि मैं शायद कुछ गलत समझ रहा हूं लेकिन अगर आप करते हैं

import Sentry from './sentry'; // this calls Sentry.init under the hood

export const handler = async (event, context) => {
  try {
    ...
  } catch (error) {
    Sentry.captureException(error);
    await Sentry.getCurrentHub().getClient().close(2000);

    return formatError(error);
  }
}

यह बिल्कुल await Sentry.flush जैसा ही है कि आप टाइमआउट को परिभाषित करते हैं।

वादा 2000ms के बाद निश्चित रूप से false के साथ हल हो जाता है यदि कतार में अभी भी सामान था।
अन्यथा close true के साथ हल हो जाएगा यदि समय समाप्त होने से पहले कतार को हटा दिया गया है।

या सभी वादों को पूरा करने से पहले कंटेनर का पुन: उपयोग किया जाएगा? (मैं इसकी कल्पना नहीं कर सकता)

@HazAT समस्या नहीं है कि close(...) क्लाइंट को फिर से उपयोग करने से रोकेगा? लैम्ब्डा उसी नोड प्रक्रिया का पुन: उपयोग करता है, इसलिए कॉल कुछ इस तरह होगी, जो मुझे लगता है कि पहली कॉल के बाद close पर काम करना बंद कर देगा?

• Sentry.init()
• Sentry.captureException()
• Sentry.getCurrentHub().getClient().close()
• Sentry.captureException()
• Sentry.getCurrentHub().getClient().close()
• Sentry.captureException()
• Sentry.getCurrentHub().getClient().close()
• Sentry.captureException()
• Sentry.getCurrentHub().getClient().close()
• ...

नहीं, close ग्राहक का निपटान नहीं करता है, यह सिर्फ परिवहन कतार को निकालने के लिए है।
मैं मानता हूं कि इस संदर्भ में नाम close भ्रामक हो सकता है लेकिन कम से कम JS/Node में close क्लाइंट के साथ कुछ भी नहीं करता है और बाद में इसका उपयोग करना पूरी तरह से ठीक है।

संपादित करें: यदि वह वास्तव में "मुद्दा" था तो मैं इसे स्पष्ट करने के लिए दस्तावेज़ों को अपडेट कर दूंगा।

ठंडा। लेकिन दस्तावेज तब गलत है:

After shutdown the client cannot be used any more so make sure to only do that right before you shut down the application.

ठीक है, हमने अभी इस मामले पर टीम में आंतरिक रूप से चर्चा की है।
आप लोग सही थे और जबकि जावास्क्रिप्ट अभी उस तरह से व्यवहार नहीं करता है जैसा हमने इसे प्रलेखित किया है हम एक flush फ़ंक्शन पेश करेंगे जो ठीक वही करेगा जो आप उम्मीद करते हैं।

तो अभी आप बिना किसी समस्या के close का उपयोग कर सकते हैं (सुनिश्चित नहीं है कि हम भविष्य में ग्राहक को निपटाने/अक्षम करने के लिए इसे बदलने जा रहे हैं)।
लेकिन एक flush फ़ंक्शन होगा जो _just_ flush कतार में है।

फीचर आने के बाद मैं इस मुद्दे को अपडेट कर दूंगा।

चूंकि मैं इन सभी टिप्पणियों में थोड़ा खो गया हूं, क्या यह है कि एक्सप्रेस त्रुटि हैंडलर (इस रेपो से एक की नकल करना) कैसा दिखना चाहिए?

function getStatusCodeFromResponse(error) {
    const statusCode = error.status || error.statusCode || error.status_code || (error.output && error.output.statusCode);
    return statusCode ? parseInt(statusCode, 10) : 500;
}

app.use(async (err, req, res, next) => {
    const status = getStatusCodeFromResponse(err);

    if (status >= 500) {
        Sentry.captureException(err)

        await Sentry.getCurrentHub().getClient().close(2000)
    }

    next(err)
})

ऐसा लगता है कि यह काम कर रहा है और यह @rreynier के कोड की तरह अतिरिक्त डेटा नहीं खोता है।

व्यक्तिगत रूप से मुझे लगता है कि

await Sentry.getCurrentHub().getClient().captureException(err)

से क्लीनर है:

Sentry.captureException(err)
await Sentry.getCurrentHub().getClient().close(2000)

close वास्तव में पढ़ता है जैसे यह क्लाइंट को बंद कर देगा ...

पूरा उदाहरण:

import * as Sentry from '@sentry/node'

// ...

Sentry.init({ dsn: config.SENTRY_DSN })

// ...

app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  let status = (err.status || err.statusCode || 500) as number

  if (process.env.NODE_ENV === 'test') {
    return next(err)
  }

  if (status < 400 || status >= 500) {
    Sentry.getCurrentHub().getClient().captureException(err).then(() => next(err))
  } else {
    next(err)
  }
})

@LinusU मैंने कोशिश की और किसी कारण से, यह स्टैक ट्रेस के साथ अतिरिक्त डेटा नहीं भेजता है। यह मूल रूप से सिर्फ स्टैक ट्रेस भेजता है। उपयोगकर्ता, ओएस या कुछ भी के बारे में कोई जानकारी नहीं।

आह, यह बिल्कुल भी अच्छा नहीं है

जबकि हम flush की प्रतीक्षा करते हैं, उपरोक्त दोनों विकल्पों की तुलना में अधिक विश्वसनीय समाधान के रूप में आप रिपोर्ट कर सकते हैं और परिणाम की प्रतीक्षा कर सकते हैं, _और_ नीचे दिए गए स्निपेट का उपयोग करके दायरा शामिल करें:

const scope = Sentry.getCurrentHub().getScope();
await Sentry.getCurrentHub().getClient().captureException(error, scope);

मैं इसका उपयोग कर रहा हूं, और ऐसा लगता है कि मेरे लिए विश्वसनीय रूप से काम करता है, रिपोर्ट की गई त्रुटियों के साथ जो कुछ भी मैं उम्मीद करता हूं।

मैं वास्तव में नेटलिफाई फंक्शंस के साथ यह सब उपयोग कर रहा हूं, लेकिन सिद्धांत लैम्ब्डा आदि के साथ समान है। मैंने एक पोस्ट लिखा है जिसमें यह काम करने के तरीके के बारे में पूरी जानकारी है, अगर कोई दिलचस्पी लेता है: https://httptoolkit। तकनीक/ब्लॉग/netlify-फ़ंक्शन-त्रुटि-रिपोर्टिंग-साथ-संतरी/

मैं वर्तमान में अपने सभी लैम्ब्डा में इस सहायक का उपयोग करता हूं।

@pimterry क्या यह मूल रूप से वही समाधान नहीं है जैसा @LinusU ने सुझाया था? मैंने इसे आजमाया है और यह अतिरिक्त डेटा भी नहीं भेजता है।

इस दृष्टिकोण ने मेरे लिए अब तक काम किया है @ondrowan

@ondrowan यह वही है, लेकिन मैन्युअल रूप से हथियाने और वर्तमान दायरे सहित। हालांकि मुझे लगता है कि आपको अपवाद काम करने के लिए पर्याप्त होना चाहिए। पिछले संस्करण के साथ, मुझे बिना लेबल वाली घटनाएं मिल रही थीं, और अब इस बदलाव के साथ मेरे अपवाद सभी अतिरिक्त सामान्य विवरणों के साथ आते हैं।

@vietbui @albinekb @Andriy- Kulak @LinusU @dwelch2344 @jviolas @rreynier @guillaumekh @rdsedmundo @ondrowan @pimterry @zeusdeux सुनिश्चित नहीं हैं कि इस उपयोग के मामले में अभी भी कौन रुचि रखता है, इसलिए मुझे क्षमा करें यदि मुझे आपको कॉल नहीं करना चाहिए।

4.6.0 से शुरू होकर, अब कोई client/hub नृत्य नहीं है। आप बस हमारी किसी भी captureX विधि को कॉल कर सकते हैं और फिर सर्वर पर सब कुछ भेजे जाने के बाद प्रतिक्रिया की प्रतीक्षा करने के लिए Sentry.flush() का उपयोग कर सकते हैं। सभी दायरे/अतिरिक्त डेटा को बिना किसी देव सहभागिता के संरक्षित किया जाना चाहिए।

सफल/समय समाप्त अनुरोधों के साथ यहां एक उदाहरण दिया गया है।

आशा है ये मदद करेगा! :)

अच्छा!

क्या अभी भी लैम्ब्डा और अन्य सर्वर रहित समाधानों से अपवादों को पकड़ने के लिए न्यूनतम पैकेज बनाने की योजना है? मुझे लगता है कि यह अभी भी एक बहुत अच्छा जोड़ होगा ❤️

@LinusU उम्मीद है कि हाँ, लेकिन हम अभी अन्य भाषाओं के एसडीके के साथ बह गए हैं

सभी संभावित समाधानों के लिए धन्यवाद, यहां आने वाले सभी लोगों के लिए टीएल; डॉ

उपयोग करें: await Sentry.flush() सभी लंबित अनुरोध भेजने के लिए, इसे 4.6.x में पेश किया गया है।

इसे बंद करते हुए, कृपया बेझिझक एक नया अंक खोलने के लिए कहें, अगर कुछ भी गायब है (लेकिन यह धागा पहले से ही बहुत लंबा है)।

चीयर्स

@kamilogorek अरे! एक त्वरित fyi, मैं पुराने वर्कअराउंड के स्थान पर अपने ऐप में Sentry.flush का उपयोग कर रहा हूं और किसी भी त्रुटि की सूचना नहीं दी जा रही है। मैं वर्तमान में अद्यतन flush पद्धति से पुराने समाधान पर वापस लौट रहा हूं।

@zeusdeux क्या इसके लिए आप कुछ डीबग जानकारी/रेप्रो केस प्रदान कर सकते हैं?
आप captureException विधि को ओवरराइड कर रहे हैं जो ईवेंट को बफर में जोड़ता है, और फिर आपको flush await चाहिए। क्या आपने इसे "नियमित तरीके से" उपयोग करने का प्रयास किया है?

@kamilogorek मेरी इच्छा है कि मेरे पास डीबग जानकारी हो लेकिन लॉग में कुछ भी नहीं है। मैंने हमेशा await को ओवरराइड captureException पर किया । नियमित रूप से, क्या आपका मतलब captureException को ओवरराइड किए बिना है?

@zeusdeux बिल्कुल, बिना किसी ओवरराइड के हमारे मूल Sentry.captureException(error) को कॉल करें।

तो आपका सहायक होगा:

import * as Sentry from '@sentry/node'

export function init({ host, method, lambda, deployment }) {
  const environment = host === process.env.PRODUCTION_URL ? 'production' : host

  Sentry.init({
    dsn: process.env.SENTRY_DSN,
    environment,
    beforeSend(event, hint) {
      if (hint && hint.originalException) {
        // eslint-disable-next-line
        console.log('Error:', hint.originalException);
      }
      return event;
    }
  })

  Sentry.configureScope(scope => {
    scope.setTag('deployment', deployment)
    scope.setTag('lambda', lambda)
    scope.setTag('method', method)
  })
}

और कोड में आप इसे कहते हैं:

import * as Sentry from '@sentry/node'

try {
  // ...
} catch (err) {
  Sentry.captureException(err);
  await Sentry.flush(2000);
  return respondWithError('Something went wrong', 500);
}

@kamilogorek मैं इसे आज़मा दूंगा और वापस रिपोर्ट करूंगा। साथ ही, beforeSend ^_^ . पर टिप के लिए धन्यवाद

await Sentry.flush(2000);

मेरे लिए भी ~ नहीं ~ काम कर रहा है।

@tanduong क्या आप रेप्रो केस प्रदान कर सकते हैं? केवल यह कहना कि यह काम नहीं करता है, बहुत मददगार नहीं है

@kamilogorek वास्तव में, मुझे अभी पता चला है कि

await Sentry.getCurrentHub().getClient().close(2000)

मेरे लिए काम नहीं करता है क्योंकि मेरा लैम्ब्डा फ़ंक्शन वीपीसी से जुड़ा हुआ है।

मैं पुष्टि करता हूँ कि

await Sentry.flush(2000);

वास्तव में काम कर रहा है।

BTW, तो आप VPC में लैम्ब्डा से कैसे निपटेंगे? NAT गेटवे से अटैच करें? मुझे सिर्फ संतरी चाहिए लेकिन सार्वजनिक इंटरनेट नहीं।

@tanduong संतरी सार्वजनिक इंटरनेट पर है, इसलिए यदि आपका लैम्ब्डा आपके VPC के भीतर चल रहा है, तो हाँ आपके पास NAT गेटवे होना चाहिए। अन्यथा आपको होस्टेड संतरी विकल्प तलाशना होगा।

flush(2000) वास्तव में क्या कर रहा है? मेरे पास यह कोड अधिकतर ठीक काम कर रहा था लेकिन अब मेरे पास कुछ captureMessage कॉल एक साथ हो रही हैं, यह हर बार समय समाप्त हो रहा है!

वायर पर संदेशों की आंतरिक कतार को फ्लश करना

ठीक है, यह कुल समझ में आता है। मुझे लगता है कि मेरा मुद्दा तो यह है कि यह वादा कभी वापस नहीं आता है जब फ्लश करने के लिए और कुछ नहीं होता है? जब भी मैं अपने लपेटे हुए captureException fn को समवर्ती रूप से चलाता हूं तो यह मेरे हैंडलर से बाहर हो जाता है।

export const captureMessage = async (
  message: string,
  extras?: any,
): Promise<boolean> =>
  new Promise((resolve) => {
    Sentry.withScope(async (scope) => {
      if (typeof extras !== 'undefined') {
        scope.setExtras(extras)
      }
      Sentry.captureMessage(message)
      await Sentry.flush(2000)
      resolve(true)
    })
  })

await Sentry.flush() पहले कैप्चर मैसेज कॉल के बाद वास्तव में समाप्त नहीं होता है।

मेरे पास वही है जो मेरा मानना ​​​​है कि @enapupe जैसा ही मुद्दा है। यदि आप समानांतर में await client.flush(2000); पर कॉल करते हैं तो केवल पहला वादा हल हो जाता है। यह एडब्ल्यूएस लैम्ब्डा संदर्भों में हो सकता है जहां क्लाइंट को हैंडलर को कई समवर्ती कॉलों के बीच पुन: उपयोग किया जाता है।

मैं इस तरह कोड का उपयोग कर रहा हूँ:

 let client = Sentry.getCurrentHub().getClient();
  if (client) {
    // flush the sentry client if it has any events to send
    log('begin flushing sentry client');
    try {
      await client.flush(2000);
    } catch (err) {
      console.error('sentry client flush error:', err);
    }
    log('end flushing sentry client');
  }

लेकिन जब मैं अपने लैम्ब्डा फ़ंक्शन में तेजी से उत्तराधिकार में दो कॉल करता हूं, तो मुझे मिलता है:

  app begin flushing sentry client +2ms
  app begin flushing sentry client +0ms
  app end flushing sentry client +2ms

आप देख सकते हैं कि दूसरा वादा कभी हल नहीं हुआ।

@esetnik मैंने उस पर एक समस्या दर्ज की है: https://github.com/getsentry/sentry-javascript/issues/2131
मेरा करंट वर्कअराउंड एक रैपर फ्लश fn है जो हमेशा हल होता है (टाइमआउट के आधार पर):

const resolveAfter = (ms: number) =>
  new Promise((resolve) => setTimeout(resolve, ms))

const flush = (timeout: number) =>
  Promise.race([resolveAfter(timeout), Sentry.flush(timeout)])

@enapupe मैंने #2131 में आपके समाधान के बारे में एक नोट जोड़ा। मेरा मानना ​​​​है कि यह समवर्ती फ्लश पर प्रदर्शन रिग्रेशन का कारण बन जाएगा।

अगर किसी को कोई परेशानी हो रही है।
यह खूबसूरती से काम करता है

@सरसआर्या @HazAT
सबसे पहले... अपना समाधान साझा करने के लिए धन्यवाद! :)
configScope विधि का एक कॉलबैक है जो मुझे लगता है कि इसे कैप्चर अपवाद से पहले बुलाया जाना चाहिए लेकिन यह उसी "थ्रेड" में नहीं किया जा रहा है।
क्या यह दौड़ की स्थिति की उपस्थिति का कारण नहीं बन सका?

@cibergarri मुझे ऐसा नहीं लगता, मेरे लिए तुल्यकालिक दिखता है, यदि आपके पास वहां एक एसिंक विधि है, तो दौड़ की स्थिति होगी।
विचार सरणी के मानचित्र जैसा है कि वही बात यहां हो रही है। यदि आपको इसके चारों ओर अपना सिर लपेटने में समस्या है। मुझे आशा है कि वह मदद करेंगे।

हाँ, ऐसा करना बिलकुल ठीक है

अपडेट: संतरी अब नोड/लैम्ब्डा वातावरण के लिए स्वचालित त्रुटि कैप्चर का समर्थन करता है: https://docs.sentry.io/platforms/node/guides/aws-lambda/

मैं इस तरह @ संतरी/सर्वर रहित का उपयोग कर रहा हूं:

const Sentry = require("@sentry/serverless");
Sentry.AWSLambda.init({
  dsn: process.env.SENTRY_DSN,
  tracesSampleRate: 1.0,
  environment: appEnv
});

exports.main = Sentry.AWSLambda.wrapHandler(async (event, context) => {
     try{
           //my code
     }catch(error){
          Sentry.captureException(error);
          await Sentry.flush(3000);
     }

});

यह लैम्ब्डा पर काम नहीं करता है।
मेरे परीक्षण एनवी में यह काम कर रहा था लेकिन प्रोड में जहां एक समवर्ती निष्पादन होता है और कंटेनरों का पुन: उपयोग किया जाता है, यह कुल राशि का लगभग 10% लॉगिंग कर रहा है।

कोई सलाह?

@ अरमांडो25723

कृपया बताएं कि आपने यह कैसे माप लिया कि यह अपवाद घटनाओं को खो देता है? क्या आपके पास एक कोड नमूना है कि इस तरह के खोए हुए अपवाद को कैसे फेंका गया? अधिक संदर्भ चाहिए।

const Sentry = require("@sentry/serverless"); // "version": "5.27.3"
Sentry.AWSLambda.init({
  dsn: process.env.SENTRY_DSN,
  tracesSampleRate: 1.0,
  environment: appEnv
});
exports.main = Sentry.AWSLambda.wrapHandler(async (event, context) => {
     try{
           throw new Error('Test Error');
     }catch(error){
          Sentry.captureException(error);
          await Sentry.flush(3000);
     }
});

क्या हो रहा है?
यदि आमंत्रणों के बीच छोटे अंतराल के साथ कई बार फ़ंक्शन लागू किया जाता है तो ईवेंट केवल एक बार लॉग किया जाता है।
यदि इनवोकेशन के बीच का समय अंतराल बड़ा है तो सभी इवेंट लॉग हो जाते हैं।

मुझे लगता है कि समस्या तब होती है जब आमंत्रण एक पुन: उपयोग किए गए कंटेनर पर होता है।

मैंने भी कोशिश की है
await Sentry.captureException(error);
तथा:
await Sentry.flush();
और निस्तब्धता के बिना
वही परिणाम

@ मार्शल-ली आप क्या सलाह देते हैं? क्या मुझे कोई समस्या पैदा करनी चाहिए, मैं यहाँ फंस गया हूँ।

@ armando25723 ऐसा लगता है कि सर्वर इन घटनाओं को भेजते समय 429 (बहुत अधिक अपवाद) के साथ प्रतिक्रिया दे रहा है। हम इसे अधिक कोटा/दर सीमित करने वाले परिदृश्यों के मामले में फेंक देते हैं। क्या आप जानते हैं कि आप क्रमिक रूप से त्रुटियाँ भेज रहे हैं या कोटा से अधिक? हम आगे डिबग कर सकते हैं यदि आपको लगता है कि ये वास्तविक त्रुटि घटनाएं हैं और आप फ्री टियर के लिए हमारी 5k सीमा के अंतर्गत हैं।

@ajjindal अन्य सभी परियोजनाएं संतरी के साथ ठीक काम कर रही हैं। संगठन स्लग "एलेग्रा" है, प्रोजेक्ट का नाम मेल-डिस्पैच-सर्वर रहित है #mail-micros के अंतर्गत। हम लंबे समय से संतरी का उपयोग कर रहे हैं, लेकिन पहली बार सर्वर रहित। यह फ्री टियर नहीं है, मैं आपको यह नहीं बता सकता कि हम किस प्लान का उपयोग कर रहे हैं लेकिन यह पेड है।
यह अच्छा होगा यदि आप मुझे और डीबग करने में मदद कर सकें।
जवाब के लिए धन्यवाद : )

पीडी: टीम प्लान है