14673141677

Committed 25 Apr 2025 08:41PM UTC coverage: 82.446%. First build

Build # 14673141677

Build Type

Pull #135

github

Committed by

web-flow

Commit Message

chore(deps-dev): bump @modelcontextprotocol/inspector

Bumps [@modelcontextprotocol/inspector](https://github.com/modelcontextprotocol/inspector) from 0.8.2 to 0.10.2.
- [Release notes](https://github.com/modelcontextprotocol/inspector/releases)
- [Commits](https://github.com/modelcontextprotocol/inspector/compare/0.8.2...0.10.2)

---
updated-dependencies:
- dependency-name: "@modelcontextprotocol/inspector"
  dependency-version: 0.10.2
  dependency-type: direct:development
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #135: chore(deps-dev): bump @modelcontextprotocol/inspector from 0.8.2 to 0.10.2

Run Details

135 of 212 branches covered (63.68%)

Branch coverage included in aggregate %.

748 of 859 relevant lines covered (87.08%)

48.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.29

/src/telemetry/eventCache.ts

import { BaseEvent } from "./types.js";
import { LRUCache } from "lru-cache";

/**
 * Singleton class for in-memory telemetry event caching
 * Provides a central storage for telemetry events that couldn't be sent
 * Uses LRU cache to automatically drop oldest events when limit is exceeded
 */
export class EventCache {
    private static instance: EventCache;
    private static readonly MAX_EVENTS = 1000;

    private cache: LRUCache<number, BaseEvent>;
    private nextId = 0;

    private constructor() {
        this.cache = new LRUCache({
            max: EventCache.MAX_EVENTS,
            // Using FIFO eviction strategy for events
            allowStale: false,
            updateAgeOnGet: false,
        });
    }

    /**
     * Gets the singleton instance of EventCache
     * @returns The EventCache instance
     */
    public static getInstance(): EventCache {
        if (!EventCache.instance) {
            EventCache.instance = new EventCache();
        }
        return EventCache.instance;
    }

    /**
     * Gets a copy of the currently cached events
     * @returns Array of cached BaseEvent objects
     */
    public getEvents(): BaseEvent[] {
        return Array.from(this.cache.values());
    }

    /**
     * Appends new events to the cached events
     * LRU cache automatically handles dropping oldest events when limit is exceeded
     * @param events - The events to append
     */
    public appendEvents(events: BaseEvent[]): void {
        for (const event of events) {
            this.cache.set(this.nextId++, event);
        }
    }

    /**
     * Clears all cached events
     */
    public clearEvents(): void {
        this.cache.clear();
        this.nextId = 0;
    }
}

1	import { BaseEvent } from "./types.js";
2	import { LRUCache } from "lru-cache";	31✔
3
4	/**
5	* Singleton class for in-memory telemetry event caching
6	* Provides a central storage for telemetry events that couldn't be sent
7	* Uses LRU cache to automatically drop oldest events when limit is exceeded
8	*/
9	export class EventCache {	31✔
10	private static instance: EventCache;
11	private static readonly MAX_EVENTS = 1000;	31✔
12
13	private cache: LRUCache<number, BaseEvent>;
14	private nextId = 0;	26✔
15
16	private constructor() {
17	this.cache = new LRUCache({	26✔
18	max: EventCache.MAX_EVENTS,
19	// Using FIFO eviction strategy for events
20	allowStale: false,
21	updateAgeOnGet: false,
22	});
23	}
24
25	/**
26	* Gets the singleton instance of EventCache
27	* @returns The EventCache instance
28	*/
29	public static getInstance(): EventCache {
30	if (!EventCache.instance) {	28✔
31	EventCache.instance = new EventCache();	26✔
32	}
33	return EventCache.instance;	28✔
34	}
35
36	/**
37	* Gets a copy of the currently cached events
38	* @returns Array of cached BaseEvent objects
39	*/
40	public getEvents(): BaseEvent[] {
41	return Array.from(this.cache.values());	×
42	}
43
44	/**
45	* Appends new events to the cached events
46	* LRU cache automatically handles dropping oldest events when limit is exceeded
47	* @param events - The events to append
48	*/
49	public appendEvents(events: BaseEvent[]): void {
50	for (const event of events) {	×
51	this.cache.set(this.nextId++, event);	×
52	}
53	}
54
55	/**
56	* Clears all cached events
57	*/
58	public clearEvents(): void {
59	this.cache.clear();	×
60	this.nextId = 0;	×
61	}
62	}

mongodb-js / mongodb-mcp-server / 14673141677

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous