FilesExpand file tree

main

/

warm-server.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

102 lines (86 loc) · 3.7 KB

main

/

warm-server.ts

Copy path

Top

File metadata and controls

• Code
• Blame

102 lines (86 loc) · 3.7 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

import statsd, { adaptForTimer } from '@/observability/lib/statsd'

import { loadUnversionedTree, loadSiteTree, loadPages, loadPageMap } from './page-data'

import loadRedirects from '@/redirects/lib/precompile'

import { createLogger } from '@/observability/logger'

const logger = createLogger(import.meta.url)

type WarmServerResult = {

pages: Awaited<ReturnType<typeof loadPageMap>>

redirects: Awaited<ReturnType<typeof loadRedirects>>

unversionedTree: Awaited<ReturnType<typeof loadUnversionedTree>>

siteTree: Awaited<ReturnType<typeof loadSiteTree>>

pageList: Awaited<ReturnType<typeof loadPages>>

pageMap: Awaited<ReturnType<typeof loadPageMap>>

}

// Datadog timers track each warm-server phase.

const dog = {

loadUnversionedTree: statsd.asyncTimer(

adaptForTimer(loadUnversionedTree),

'load_unversioned_tree',

),

loadSiteTree: statsd.asyncTimer(adaptForTimer(loadSiteTree), 'load_site_tree'),

loadPages: statsd.asyncTimer(adaptForTimer(loadPages), 'load_pages'),

loadPageMap: statsd.asyncTimer(adaptForTimer(loadPageMap), 'load_page_map'),

loadRedirects: statsd.asyncTimer(adaptForTimer(loadRedirects), 'load_redirects'),

warmServer: statsd.asyncTimer(adaptForTimer(warmServer), 'warm_server'),

}

let promisedWarmServer: Promise<WarmServerResult> | undefined

async function warmServer(languagesOnly: string[] = []): Promise<WarmServerResult> {

const startTime = Date.now()

const langSuffix =

languagesOnly && languagesOnly.length ? ` (${languagesOnly.join(',')})` : ' (all languages)'

logger.info(`warm-server: starting${langSuffix}`)

let stepStart = Date.now()

const unversionedTree = await dog.loadUnversionedTree(languagesOnly)

logger.info('warm-server: loadUnversionedTree complete', {

durationMs: Date.now() - stepStart,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

stepStart = Date.now()

const siteTree = await dog.loadSiteTree(unversionedTree, languagesOnly)

logger.info('warm-server: loadSiteTree complete', {

durationMs: Date.now() - stepStart,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

stepStart = Date.now()

const pageList = await dog.loadPages(unversionedTree, languagesOnly)

logger.info('warm-server: loadPages complete', {

durationMs: Date.now() - stepStart,

pageCount: pageList.length,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

stepStart = Date.now()

const pageMap = await dog.loadPageMap(pageList, [])

logger.info('warm-server: loadPageMap complete', {

durationMs: Date.now() - stepStart,

permalinkCount: Object.keys(pageMap).length,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

stepStart = Date.now()

const redirects = await dog.loadRedirects(pageList)

logger.info('warm-server: loadRedirects complete', {

durationMs: Date.now() - stepStart,

redirectCount: Object.keys(redirects).length,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

statsd.gauge('memory_heap_used', process.memoryUsage().heapUsed, ['event:warm-server'])

logger.info('warm-server: complete', {

totalDurationMs: Date.now() - startTime,

heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),

})

return {

pages: pageMap,

redirects,

unversionedTree,

siteTree,

pageList,

pageMap,

}

}

// Warm-server statistics record only the first request that performs priming.

export default async function warmServerWrapper(languagesOnly: string[] = []) {

// Concurrent requests share the in-progress Promise instead of loading files multiple times.

if (!promisedWarmServer) {

promisedWarmServer = dog.warmServer(languagesOnly)

}

return promisedWarmServer

}