shutdown()

1
async shutdown(): Promise<void>

1
import { RespanTelemetry } from '@respan/tracing';
2
3
const respanAi = new RespanTelemetry({
4
    apiKey: process.env.RESPAN_API_KEY,
5
    appName: 'my-app'
6
});
7
8
await respanAi.initialize();
9
10
await respanAi.withWorkflow(
11
    { name: 'my_workflow' },
12
    async () => {
13
        return await processData();
14
    }
15
);
16
17
// Close the tracer when this process is done tracing
18
await respanAi.shutdown();
19
console.log('Tracing shutdown complete');

1
async function main() {
2
    const respanAi = new RespanTelemetry({
3
        apiKey: process.env.RESPAN_API_KEY,
4
        appName: 'my-app'
5
    });
6
    
7
    try {
8
        // Initialize
9
        await respanAi.initialize();
10
        console.log('Tracing initialized');
11
        
12
        // Run your application
13
        await respanAi.withWorkflow(
14
            { name: 'main_workflow' },
15
            async () => {
16
                return await runApplication();
17
            }
18
        );
19
    } catch (error) {
20
        console.error('Application error:', error);
21
    } finally {
22
        // Always shutdown, even on error
23
        await respanAi.shutdown();
24
        console.log('Tracing shutdown complete');
25
    }
26
}
27
28
main();

1
const respanAi = new RespanTelemetry({
2
    apiKey: process.env.RESPAN_API_KEY,
3
    appName: 'my-server'
4
});
5
6
await respanAi.initialize();
7
8
// Handle shutdown signals
9
process.on('SIGTERM', async () => {
10
    console.log('SIGTERM received, shutting down gracefully...');
11
    await respanAi.shutdown();
12
    process.exit(0);
13
});
14
15
process.on('SIGINT', async () => {
16
    console.log('SIGINT received, shutting down gracefully...');
17
    await respanAi.shutdown();
18
    process.exit(0);
19
});
20
21
// Run application
22
await runServer();

1
import express from 'express';
2
3
const app = express();
4
5
const respanAi = new RespanTelemetry({
6
    apiKey: process.env.RESPAN_API_KEY,
7
    appName: 'api-server'
8
});
9
10
await respanAi.initialize();
11
12
app.get('/api/data', async (req, res) => {
13
    await respanAi.withWorkflow(
14
        { name: 'api_request' },
15
        async () => {
16
            const data = await fetchData();
17
            res.json(data);
18
        }
19
    );
20
});
21
22
const server = app.listen(3000, () => {
23
    console.log('Server running on port 3000');
24
});
25
26
// Graceful shutdown
27
async function gracefulShutdown() {
28
    console.log('Shutting down gracefully...');
29
    
30
    // Stop accepting new requests
31
    server.close(async () => {
32
        console.log('HTTP server closed');
33
        
34
        // Shutdown tracing
35
        await respanAi.shutdown();
36
        console.log('Tracing shutdown complete');
37
        
38
        process.exit(0);
39
    });
40
    
41
    // Force exit after 10 seconds
42
    setTimeout(() => {
43
        console.error('Forced shutdown after timeout');
44
        process.exit(1);
45
    }, 10000);
46
}
47
48
process.on('SIGTERM', gracefulShutdown);
49
process.on('SIGINT', gracefulShutdown);

1
async function processJobs() {
2
    const respanAi = new RespanTelemetry({
3
        apiKey: process.env.RESPAN_API_KEY,
4
        appName: 'job-worker'
5
    });
6
    
7
    await respanAi.initialize();
8
    
9
    let shouldStop = false;
10
    
11
    process.on('SIGTERM', () => {
12
        console.log('Stopping job processing...');
13
        shouldStop = true;
14
    });
15
    
16
    try {
17
        while (!shouldStop) {
18
            const job = await getNextJob();
19
            
20
            if (job) {
21
                await respanAi.withWorkflow(
22
                    { name: 'process_job' },
23
                    async () => {
24
                        return await processJob(job);
25
                    }
26
                );
27
            } else {
28
                await new Promise(resolve => setTimeout(resolve, 1000));
29
            }
30
        }
31
    } finally {
32
        await respanAi.shutdown();
33
        console.log('Worker shutdown complete');
34
    }
35
}
36
37
processJobs();

1
#!/usr/bin/env node
2
import { program } from 'commander';
3
4
async function runCLI() {
5
    const respanAi = new RespanTelemetry({
6
        apiKey: process.env.RESPAN_API_KEY,
7
        appName: 'cli-tool'
8
    });
9
    
10
    await respanAi.initialize();
11
    
12
    program
13
        .command('process <file>')
14
        .action(async (file) => {
15
            try {
16
                await respanAi.withWorkflow(
17
                    { name: 'cli_process' },
18
                    async () => {
19
                        return await processFile(file);
20
                    }
21
                );
22
                console.log('Processing complete');
23
            } catch (error) {
24
                console.error('Error:', error);
25
                process.exit(1);
26
            } finally {
27
                await respanAi.shutdown();
28
            }
29
        });
30
    
31
    await program.parseAsync();
32
}
33
34
runCLI();

1
import { describe, it, beforeAll, afterAll } from '@jest/globals';
2
3
describe('My Service', () => {
4
    let respanAi: RespanTelemetry;
5
    
6
    beforeAll(async () => {
7
        respanAi = new RespanTelemetry({
8
            apiKey: process.env.RESPAN_API_KEY,
9
            appName: 'test-suite'
10
        });
11
        await respanAi.initialize();
12
    });
13
    
14
    afterAll(async () => {
15
        // Shutdown after all tests
16
        await respanAi.shutdown();
17
    });
18
    
19
    it('should process data', async () => {
20
        await respanAi.withWorkflow(
21
            { name: 'test_workflow' },
22
            async () => {
23
                const result = await processData();
24
                expect(result).toBeDefined();
25
            }
26
        );
27
    });
28
});