Measuring time needed for querying data from indexedDB with Dexie

[shwarcu]

Hi, I am using MSW to mock requests performed by application. I added Dexie to this setup in order to simulate behaviour of real API (ability to create entities and then fetch them and much more).

I would like to measure time that Dexie adds up to my handlers and I'm not sure if this is the right way of doing it. I would appreciate suggestions how to correctly measure timings of operations on the DB.

Example handler and how I attempt to measure time:

  rest.get(
    'https://my.app.api.com/item/:itemId',
    async (req: RestRequest<never, { itemId: string }>, res, ctx) => {
      const start = performance.now();

      const itemId = req.params.itemId;
      const item = await db.items.get(itemId);
      if (!item) {
        return res(ctx.status(404), ctx.json({ error: 'Not found' }));
      }
      const end = performance.now();
      console.log('[Performance] Query for item took [ms]', Math.floor(end - start));
      return res(ctx.status(200), ctx.json(ticket));
    }
  ),

I measured all handlers in this way. Result is that when my application starts, some handlers take 700-900ms to execute (measured by above method) and this is worries me as those handlers are very often just taking all entities from the table and returning them (it's mostly just few objects).
I would like to understand if Dexie is slowing down my handlers.

[dfahlander]

When you hit the very first request, dexie will take the chance to open the database in the background which will add time to the measuring. To avoiding measuring the time it takes to open the database, make sure the database is already opened.

You could add this line before const start = performance.now();:

if (!db.isOpen()) await db.open();

[shwarcu]

@dfahlander does it also mean that multiple requests could be waiting for database to be opened? Like in this example, data size and queries complexity is tiny, but requests take quite long time to be handled

[dfahlander]

Once database has been opened, it will never need to wait for open again (unless explicitely closed). But yes if multiple requests are done in parallel before db is open, all of them will be queued until the open procedure to complete. It's hard to know if this is the case here though as it seems you have speedy requests in your log before the slow ones which indicates that the db would already be open (assuming the first requests operate on the same db instance).

But if you add my line as I suggested, you will eliminate the risk of measuring db.open(). If you still have slow requests, there could be other reasons such as if the objects returned would be deeply structured and/large in content.

[shwarcu]

Thanks a lot for explaining. I will apply your suggestion and I will keep digging :)