﻿1
00:00:01,150 --> 00:00:03,353
‫Jonas : Dans cette vidéo,

2
00:00:03,353 --> 00:00:06,390
‫nous allons implémenter une logique afin d'envoyer différents messages

3
00:00:06,390 --> 00:00:09,173
‫d'erreur pour l'environnement de développement et de production.

4
00:00:10,810 --> 00:00:14,490
‫Donc en ce moment, nous envoyons ce même message de réponse ici essentiellement

5
00:00:14,490 --> 00:00:17,389
‫à tout le monde, peu importe si nous sommes en

6
00:00:17,389 --> 00:00:18,920
‫développement ou en production.

7
00:00:18,920 --> 00:00:21,690
‫Mais l'idée est qu'en production, nous voulons divulguer

8
00:00:21,690 --> 00:00:23,810
‫le moins d'informations possible sur

9
00:00:23,810 --> 00:00:25,583
‫nos erreurs au client.

10
00:00:26,420 --> 00:00:28,490
‫Donc, dans ce cas, nous voulons seulement

11
00:00:28,490 --> 00:00:30,340
‫envoyer un message agréable et

12
00:00:30,340 --> 00:00:33,070
‫convivial pour que l'utilisateur sache ce qui ne va pas.

13
00:00:33,070 --> 00:00:34,858
‫D'un autre côté, lors du

14
00:00:34,858 --> 00:00:37,700
‫développement écrit, nous voulons obtenir autant d'informations que possible sur

15
00:00:37,700 --> 00:00:40,390
‫l'erreur qui s'est produite, et nous voulons que cela

16
00:00:40,390 --> 00:00:42,950
‫soit directement dans le message d'erreur qui revient.

17
00:00:42,950 --> 00:00:45,520
‫Nous pourrions donc également enregistrer ces informations sur

18
00:00:45,520 --> 00:00:48,340
‫la console, mais je pense qu'il est bien plus utile

19
00:00:48,340 --> 00:00:51,150
‫d'avoir ces informations directement dans le facteur, dans ce cas.

20
00:00:51,150 --> 00:00:53,660
‫Ainsi, nous savons déjà faire la distinction entre

21
00:00:53,660 --> 00:00:56,010
‫l'environnement de développement et l'environnement de production.

22
00:00:56,870 --> 00:00:58,213
‫Et donc, faisons-le.

23
00:00:59,130 --> 00:00:59,963
‫Donc

24
00:01:01,630 --> 00:01:05,010
‫si processus. env. node_env est

25
00:01:06,510 --> 00:01:08,970
‫égal au développement alors nous voulons

26
00:01:11,810 --> 00:01:13,780
‫envoyer un type d'erreur et

27
00:01:15,530 --> 00:01:17,060
‫si nous sommes

28
00:01:17,060 --> 00:01:21,020
‫en production, alors nous voulons envoyer une erreur plus simple.

29
00:01:21,020 --> 00:01:21,853
‫Bien.

30
00:01:24,290 --> 00:01:26,913
‫Donc égal à la production.

31
00:01:30,160 --> 00:01:33,343
‫Très bien, prenons celui-ci, donc encore une fois,

32
00:01:34,390 --> 00:01:36,380
‫lors du développement écrit,

33
00:01:36,380 --> 00:01:39,850
‫nous voulons obtenir toutes les informations que nous pouvons.

34
00:01:39,850 --> 00:01:43,763
‫C'est donc aussi imprimer ou répondre avec la pile d'erreurs ici.

35
00:01:48,620 --> 00:01:52,300
‫Alors errez. pile, puis affichons

36
00:01:52,300 --> 00:01:54,483
‫également l'intégralité de l'erreur.

37
00:01:56,240 --> 00:02:00,830
‫Disons une erreur et réglez-le correctement.

38
00:02:00,830 --> 00:02:02,003
‫Ensuite, d'un

39
00:02:03,030 --> 00:02:05,183
‫autre côté, copions à nouveau ceci.

40
00:02:06,040 --> 00:02:09,350
‫Lorsque nous sommes en production, nous ne voulons pas de la pile

41
00:02:09,350 --> 00:02:12,493
‫et nous ne voulons pas non plus de l'erreur complète.

42
00:02:13,490 --> 00:02:16,113
‫Donc vraiment juste le statut et le message.

43
00:02:19,190 --> 00:02:20,933
‫Cela semble un peu

44
00:02:21,930 --> 00:02:24,550
‫compliqué, alors exportons-les dans leurs propres fonctions

45
00:02:24,550 --> 00:02:27,440
‫et aussi parce que nous allons en fait

46
00:02:27,440 --> 00:02:30,719
‫ajouter beaucoup plus de code ici, dans cette branche else.

47
00:02:30,719 --> 00:02:33,730
‫C'est un peu plus propre de les avoir dans

48
00:02:33,730 --> 00:02:35,180
‫leurs propres fonctions distinctes.

49
00:02:36,500 --> 00:02:37,550
‫Supposons donc

50
00:02:39,540 --> 00:02:41,480
‫que const envoie une erreur pour

51
00:02:43,930 --> 00:02:46,470
‫dev et cette fonction devrait alors recevoir l'erreur,

52
00:02:46,470 --> 00:02:49,903
‫et nous devons également transmettre le sujet de la réponse.

53
00:02:51,990 --> 00:02:54,930
‫C'est parce que c'est ainsi que nous pouvons

54
00:02:54,930 --> 00:02:57,223
‫envoyer la réponse, n'est-ce pas ?

55
00:02:58,360 --> 00:03:02,090
‫Nous avons donc besoin du sujet de la réponse pour pouvoir exécuter

56
00:03:02,090 --> 00:03:02,933
‫ce code.

57
00:03:04,080 --> 00:03:06,510
‫Ici, nous allons juste appeler

58
00:03:07,410 --> 00:03:08,990
‫send error dev

59
00:03:09,890 --> 00:03:11,263
‫avec

60
00:03:11,263 --> 00:03:13,073
‫l'erreur et la réponse.

61
00:03:14,270 --> 00:03:15,483
‫Ensuite, ici,

62
00:03:17,030 --> 00:03:18,030
‫nous

63
00:03:18,030 --> 00:03:21,783
‫allons envoyer la production d'erreurs, les

64
00:03:24,830 --> 00:03:26,253
‫mêmes arguments.

65
00:03:36,300 --> 00:03:37,500
‫Et puis ici, pareil.

66
00:03:43,041 --> 00:03:46,740
‫C'était donc facile, passons maintenant au niveau supérieur et

67
00:03:46,740 --> 00:03:49,810
‫parlons à nouveau des erreurs opérationnelles.

68
00:03:49,810 --> 00:03:53,230
‫Pour cela, permettez-moi d'ouvrir la classe d'erreur d'application que

69
00:03:53,230 --> 00:03:56,270
‫nous avons créée, et rappelons-nous que nous

70
00:03:56,270 --> 00:03:57,870
‫marquons toutes les

71
00:03:57,870 --> 00:04:02,313
‫erreurs que nous créons, en utilisant AppError est opérationnel défini sur true.

72
00:04:03,721 --> 00:04:05,760
‫Donc, toutes les erreurs que nous

73
00:04:05,760 --> 00:04:07,873
‫créons nous-mêmes seront essentiellement des erreurs opérationnelles.

74
00:04:09,100 --> 00:04:11,950
‫En fait, ce ne sont que ces erreurs opérationnelles

75
00:04:11,950 --> 00:04:14,540
‫pour lesquelles nous voulons envoyer le message

76
00:04:14,540 --> 00:04:15,703
‫d'erreur au client.

77
00:04:16,720 --> 00:04:18,310
‫Au moins en production.

78
00:04:18,310 --> 00:04:21,900
‫Ainsi, lorsque nous avons, par contre, une erreur de programmation

79
00:04:21,900 --> 00:04:23,880
‫ou une autre erreur inconnue provenant,

80
00:04:23,880 --> 00:04:26,500
‫par exemple, d'un package tiers, nous ne

81
00:04:26,500 --> 00:04:29,930
‫voulons pas envoyer de message d'erreur à ce sujet

82
00:04:29,930 --> 00:04:31,864
‫au client en production.

83
00:04:31,864 --> 00:04:33,470
‫Et donc ça ne sert à rien.

84
00:04:33,470 --> 00:04:37,340
‫C'est une propriété opérationnelle ici dans notre contrôleur d'erreur.

85
00:04:37,340 --> 00:04:40,090
‫Rappelez-vous comment j'ai déjà parlé de le faire

86
00:04:40,090 --> 00:04:43,693
‫au moment où nous avons créé cette classe, n'est-ce pas ?

87
00:04:45,580 --> 00:04:48,780
‫Venons-en maintenant ici pour envoyer la production d'erreurs et

88
00:04:49,730 --> 00:04:50,913
‫faire ce test.

89
00:04:52,270 --> 00:04:54,787
‫Si erreur. isOperational uniquement

90
00:05:00,630 --> 00:05:05,053
‫dans ce cas, nous voulons réellement envoyer cette erreur ici.

91
00:05:06,940 --> 00:05:08,113
‫Dans tous

92
00:05:10,070 --> 00:05:11,330
‫les autres cas, nous

93
00:05:11,330 --> 00:05:14,580
‫allons simplement envoyer un message d'erreur très générique au client.

94
00:05:14,580 --> 00:05:17,310
‫Alors disons, res. status et nous

95
00:05:19,400 --> 00:05:22,110
‫allons simplement envoyer un code 500 générique,

96
00:05:23,930 --> 00:05:25,123
‫puis json.

97
00:05:28,120 --> 00:05:30,363
‫Le statut sera erreur.

98
00:05:33,230 --> 00:05:36,660
‫Ensuite, envoyons simplement un message générique, disant que quelque

99
00:05:38,200 --> 00:05:39,033
‫chose s'est

100
00:05:41,360 --> 00:05:42,573
‫très mal passé.

101
00:05:43,690 --> 00:05:46,983
‫Donc, faire quelque chose comme ça est une procédure très standard.

102
00:05:48,420 --> 00:05:51,133
‫Permettez-moi de commenter une partie du code ici.

103
00:05:54,530 --> 00:05:57,533
‫Il s'agit donc d'une erreur opérationnelle à laquelle nous faisons confiance.

104
00:06:03,700 --> 00:06:06,200
‫Ici, nous voulons envoyer un message au client.

105
00:06:06,200 --> 00:06:07,503
‫Mais dans ce

106
00:06:16,130 --> 00:06:17,973
‫cas ici, nous avons une erreur

107
00:06:19,080 --> 00:06:22,673
‫inconnue, et nous ne voulons donc pas divulguer les détails au client.

108
00:06:28,470 --> 00:06:31,380
‫Nous allons donc simplement envoyer ce message au client,

109
00:06:31,380 --> 00:06:33,070
‫et aussi pour nous-mêmes.

110
00:06:33,070 --> 00:06:35,340
‫Pour nous, développeurs, nous voulons savoir

111
00:06:35,340 --> 00:06:38,610
‫que ce genre d'erreur étrange, inattendue et inconnue s'est

112
00:06:38,610 --> 00:06:41,993
‫produite et nous allons en fait l'enregistrer sur la console.

113
00:06:49,100 --> 00:06:50,593
‫Nous allons d'abord

114
00:06:56,702 --> 00:06:59,369
‫enregistrer l'erreur, puis envoyer un message générique.

115
00:07:00,280 --> 00:07:03,270
‫Disons simplement, console. erreur, c'est donc un peu

116
00:07:03,270 --> 00:07:05,490
‫comme console. log, mais

117
00:07:05,490 --> 00:07:07,870
‫c'est vraiment spécifique aux erreurs et je

118
00:07:07,870 --> 00:07:10,670
‫pense que la sortie sera alors un peu différente.

119
00:07:12,090 --> 00:07:15,670
‫Donc erreur, ajoutons quelques emoji ici pour le rendre

120
00:07:15,670 --> 00:07:16,543
‫visible dans

121
00:07:17,950 --> 00:07:20,360
‫nos journaux, puis enregistrons également l'erreur.

122
00:07:20,360 --> 00:07:23,213
‫Maintenant, il existe de vraies bibliothèques de journalisation sur mpm, que

123
00:07:23,213 --> 00:07:24,550
‫nous pourrions utiliser ici

124
00:07:24,550 --> 00:07:28,030
‫au lieu d'avoir simplement cette simple console. erreur, mais le simple

125
00:07:28,030 --> 00:07:30,430
‫fait de consigner l'erreur sur la console la

126
00:07:30,430 --> 00:07:32,220
‫rendra visible dans les journaux

127
00:07:32,220 --> 00:07:34,363
‫de la plate-forme d'hébergement que vous utilisez.

128
00:07:35,486 --> 00:07:39,200
‫Je pense que pour l'instant, dans ce genre d'application simple,

129
00:07:39,200 --> 00:07:40,073
‫cela suffit.

130
00:07:41,110 --> 00:07:42,860
‫Par exemple, nous allons utiliser

131
00:07:42,860 --> 00:07:45,710
‫Heroku d'ici la fin du cours pour déployer notre application.

132
00:07:45,710 --> 00:07:47,600
‫Ensuite, lorsqu'une erreur comme celle-ci

133
00:07:47,600 --> 00:07:49,970
‫se produit, elle sera enregistrée dans la console.

134
00:07:49,970 --> 00:07:54,180
‫Dans la plateforme Heroku, nous avons alors accès à ces logs.

135
00:07:54,180 --> 00:07:57,080
‫Nous pouvons continuer à consulter ces journaux, puis nous

136
00:07:57,080 --> 00:07:59,220
‫y trouverons ces erreurs inattendues afin de

137
00:07:59,220 --> 00:08:00,670
‫pouvoir ensuite les corriger.

138
00:08:01,678 --> 00:08:04,470
‫À l'heure actuelle, nous construisons déjà une sorte

139
00:08:04,470 --> 00:08:07,000
‫de mécanisme de gestion des erreurs

140
00:08:07,000 --> 00:08:08,713
‫sophistiqué et réel ici.

141
00:08:09,720 --> 00:08:13,240
‫Alors récapitulons rapidement ce que nous venons de faire ici.

142
00:08:13,240 --> 00:08:16,380
‫Nous distinguons les erreurs de développement et

143
00:08:16,380 --> 00:08:17,373
‫de production.

144
00:08:18,720 --> 00:08:21,420
‫Lorsque nous sommes en production, nous envoyons l'erreur

145
00:08:21,420 --> 00:08:22,970
‫à l'aide de cette fonction

146
00:08:22,970 --> 00:08:26,050
‫ici, qui enverra ensuite le plus de détails possible

147
00:08:26,050 --> 00:08:27,340
‫au client, afin

148
00:08:27,340 --> 00:08:28,997
‫que nous obtenions vraiment toutes

149
00:08:28,997 --> 00:08:31,730
‫les informations afin de se débarrasser du bug.

150
00:08:31,730 --> 00:08:33,332
‫S'il s'agit d'une erreur

151
00:08:33,332 --> 00:08:35,670
‫de programmation ou d'une erreur opérationnelle,

152
00:08:35,670 --> 00:08:39,083
‫nous voulons toujours vraiment voir tout ce qui se passe.

153
00:08:40,670 --> 00:08:42,000
‫Lorsque nous sommes

154
00:08:42,000 --> 00:08:44,330
‫en production, ce qui est sans doute la

155
00:08:44,330 --> 00:08:47,090
‫partie la plus importante de notre application, nous distinguons

156
00:08:47,090 --> 00:08:48,590
‫alors les erreurs opérationnelles, donc

157
00:08:48,590 --> 00:08:50,950
‫les erreurs que nous connaissons et auxquelles nous

158
00:08:50,950 --> 00:08:54,163
‫avons confiance, et les autres erreurs, qui peuvent être assez inattendues.

159
00:08:55,660 --> 00:08:58,800
‫Si l'erreur est opérationnelle, par exemple l'utilisateur a essayé d'accéder

160
00:08:58,800 --> 00:09:01,530
‫à une route qui n'existe pas, ou a

161
00:09:01,530 --> 00:09:03,680
‫essayé d'entrer des données invalides, toutes

162
00:09:03,680 --> 00:09:05,253
‫ces erreurs sont opérationnelles.

163
00:09:05,253 --> 00:09:08,130
‫Ensuite, nous pouvons envoyer les messages d'erreur appropriés, pour que

164
00:09:08,130 --> 00:09:10,880
‫le client sache ce qui s'est mal passé.

165
00:09:10,880 --> 00:09:13,820
‫D'un autre côté, nous avons ces erreurs inconnues, ou

166
00:09:13,820 --> 00:09:16,380
‫des erreurs inattendues, et dans ce cas,

167
00:09:16,380 --> 00:09:19,420
‫nous disons très simplement que quelque chose s'est mal passé.

168
00:09:19,420 --> 00:09:21,670
‫Ensuite, enregistrez également l'erreur sur notre console, afin que

169
00:09:21,670 --> 00:09:24,433
‫nous sachions qu'elle s'est produite et que nous puissions ensuite la corriger.

170
00:09:25,510 --> 00:09:27,080
‫Maintenant, pour que cela fonctionne, il y

171
00:09:27,080 --> 00:09:29,160
‫a quelque chose de vraiment, vraiment important que

172
00:09:29,160 --> 00:09:30,193
‫nous devons faire.

173
00:09:31,040 --> 00:09:33,340
‫Il y a actuellement des erreurs

174
00:09:33,340 --> 00:09:37,550
‫qui viennent par exemple de MongoDB, que nous ne marquons pas comme opérationnelles.

175
00:09:37,550 --> 00:09:40,970
‫Dans ce cas, ils seraient simplement traités à l'aide

176
00:09:40,970 --> 00:09:43,500
‫de ce message d'erreur générique ici.

177
00:09:43,500 --> 00:09:45,330
‫Par exemple, une erreur de validation.

178
00:09:45,330 --> 00:09:48,000
‫À l'heure actuelle, c'est une erreur qui

179
00:09:48,000 --> 00:09:51,356
‫vient de MongoDB et non de notre propre classe d'erreur d'application.

180
00:09:51,356 --> 00:09:54,869
‫Nous ne créons pas ces erreurs par nous-mêmes.

181
00:09:54,869 --> 00:09:58,800
‫Encore une fois, ils ne sont actuellement pas marqués comme opérationnels,

182
00:09:58,800 --> 00:10:02,130
‫mais nous devons bien sûr les marquer comme opérationnels afin

183
00:10:02,130 --> 00:10:04,680
‫que nous puissions ensuite renvoyer le message

184
00:10:04,680 --> 00:10:06,400
‫d'erreur approprié au client.

185
00:10:06,400 --> 00:10:08,360
‫Dans l'exemple que je viens de mentionner,

186
00:10:08,360 --> 00:10:10,263
‫que les données d'entrée sont invalides.

187
00:10:11,250 --> 00:10:14,230
‫Il y a deux ou trois autres erreurs que nous

188
00:10:14,230 --> 00:10:15,793
‫devons nous-mêmes marquer comme opérationnelles.

189
00:10:16,930 --> 00:10:18,020
‫Nous allons

190
00:10:19,410 --> 00:10:20,670
‫donc le faire ici.

191
00:10:20,670 --> 00:10:22,193
‫Donc, dans ce bloc else,

192
00:10:23,400 --> 00:10:25,850
‫nous le ferons au cours des deux prochaines conférences.

