Enterprise customer - cannot perform I/O error

CCem Hi all - I was told to come hear from enterprise support as they were not sure w...

H

Hard@Work•8/5/24, 8:05 AM

This sounds like you are sharing promises in the global scope. I.e.

let someThing;
export default {
  async fetch() {
    someThing = await fetch("https://1.1.1.1/");
    // ...
  }
}

let someThing;
export default {
  async fetch() {
    someThing = await fetch("https://1.1.1.1/");
    // ...
  }
}

let someThing;
export default {
  async fetch() {
    someThing = await fetch("https://1.1.1.1/");
    // ...
  }
}

let someThing;
export default {
  async fetch() {
    someThing = await fetch("https://1.1.1.1/");
    // ...
  }
}

C

CemOP•8/5/24, 11:30 PM

Hi @Hard@Work | R2 - thanks for the response. However, we're not declaring any variables at the global scope.

C

CemOP•8/5/24, 11:30 PM

To help narrow it down, would you be able to tell me if that error comes from interacting with the durable object or not?

C

CemOP•8/5/24, 11:31 PM

Or what I/O operation might be throwing the error?

CCem Or what I/O operation might be throwing the error?

H

Hard@Work•8/6/24, 7:57 AM

Can you share a code snippet from where this is happening?

C

CemOP•8/7/24, 12:06 AM

@Hard@Work | R2 I'm not sure if this is where the error is coming from but the stack trace seems to suggest this method from our class:

async listViews(): Promise<ViewData[]> {
    let views: ViewData[] = [];
    try {
      const viewsRaw = await this.viewer.fetch(
        constructUrl(`${this.info.id}/list`),
      );
      views = await viewsRaw.json();
    } catch (e: any) {
      this.logger.error('Failed to fetch view list', e);
      throw e;
    }
    return views;
  }

async listViews(): Promise<ViewData[]> {
    let views: ViewData[] = [];
    try {
      const viewsRaw = await this.viewer.fetch(
        constructUrl(`${this.info.id}/list`),
      );
      views = await viewsRaw.json();
    } catch (e: any) {
      this.logger.error('Failed to fetch view list', e);
      throw e;
    }
    return views;
  }

async listViews(): Promise<ViewData[]> {
    let views: ViewData[] = [];
    try {
      const viewsRaw = await this.viewer.fetch(
        constructUrl(`${this.info.id}/list`),
      );
      views = await viewsRaw.json();
    } catch (e: any) {
      this.logger.error('Failed to fetch view list', e);
      throw e;
    }
    return views;
  }

async listViews(): Promise<ViewData[]> {
    let views: ViewData[] = [];
    try {
      const viewsRaw = await this.viewer.fetch(
        constructUrl(`${this.info.id}/list`),
      );
      views = await viewsRaw.json();
    } catch (e: any) {
      this.logger.error('Failed to fetch view list', e);
      throw e;
    }
    return views;
  }

CCem @Hard@Work | R2 I'm not sure if this is where the error is coming from but the s...

H

Hard@Work•8/7/24, 7:56 AM

How do you construct instances of this class? Where are they stored?

C

CemOP•8/8/24, 4:25 AM

Hi @Hard@Work | R2 , it is constructed during the Hono router construction under the init() method as such:

export async function constructRouter(
  request: Request,
  env: Bindings,
  logger: Logger,
  ctx: ExecutionContext,
): Promise<Hono<{ Bindings: Bindings }>> {
  const app = new Hono<{ Bindings: Bindings }>();

  // Register logging middleware
  app.use('*', async (event, next) => {
    try {
      logger.send(ctx);
      await next();
    } catch (error: any) {
      logger.error(error);
      logger.send(ctx);
      return event.json(
        {
          message: 'Server error',
        },
        500,
      );
    }
  });
  // Register CORS middleware
  app.use('*', async (event, next) => {
    await next();
    event.res.headers.set(
      'Access-Control-Allow-Origin',
      event.req.header('origin') ?? '*',
    );
    event.res.headers.set('Access-Control-Max-Age', '86400');
    event.res.headers.set(
      'Access-Control-Allow-Methods',
      'GET, PATCH, POST, PUT, DELETE, OPTIONS, HEAD',
    );
    event.res.headers.set(
      'Access-Control-Allow-Headers',
      'origin, content-type, accept, authorization, x-requested-with, x-datadog-trace-id, x-datadog-parent-id, x-datadog-origin, x-datadog-sampling-priority, x-datadog-sampled',
    );
  });

  // Register OPTIONS handler
  app.options('*', (event) => event.text(''));

  // Register User class init middleware
  app.use('*', async (event, next) => {
    try {
      event.env.User = new User(request, env, logger) as User;
      await event.env.User.init();
      await next();
    } catch (err) {
      logger.error(err, {
        user: event.env.User.info.id,
      });
      return event.json(
        {
          errors: {
            status: 401,
            title: 'You must be authenticated to access this resource',
          },
        },
        401,
      );
    }
  });

export async function constructRouter(
  request: Request,
  env: Bindings,
  logger: Logger,
  ctx: ExecutionContext,
): Promise<Hono<{ Bindings: Bindings }>> {
  const app = new Hono<{ Bindings: Bindings }>();

  // Register logging middleware
  app.use('*', async (event, next) => {
    try {
      logger.send(ctx);
      await next();
    } catch (error: any) {
      logger.error(error);
      logger.send(ctx);
      return event.json(
        {
          message: 'Server error',
        },
        500,
      );
    }
  });
  // Register CORS middleware
  app.use('*', async (event, next) => {
    await next();
    event.res.headers.set(
      'Access-Control-Allow-Origin',
      event.req.header('origin') ?? '*',
    );
    event.res.headers.set('Access-Control-Max-Age', '86400');
    event.res.headers.set(
      'Access-Control-Allow-Methods',
      'GET, PATCH, POST, PUT, DELETE, OPTIONS, HEAD',
    );
    event.res.headers.set(
      'Access-Control-Allow-Headers',
      'origin, content-type, accept, authorization, x-requested-with, x-datadog-trace-id, x-datadog-parent-id, x-datadog-origin, x-datadog-sampling-priority, x-datadog-sampled',
    );
  });

  // Register OPTIONS handler
  app.options('*', (event) => event.text(''));

  // Register User class init middleware
  app.use('*', async (event, next) => {
    try {
      event.env.User = new User(request, env, logger) as User;
      await event.env.User.init();
      await next();
    } catch (err) {
      logger.error(err, {
        user: event.env.User.info.id,
      });
      return event.json(
        {
          errors: {
            status: 401,
            title: 'You must be authenticated to access this resource',
          },
        },
        401,
      );
    }
  });

export async function constructRouter(
  request: Request,
  env: Bindings,
  logger: Logger,
  ctx: ExecutionContext,
): Promise<Hono<{ Bindings: Bindings }>> {
  const app = new Hono<{ Bindings: Bindings }>();

  // Register logging middleware
  app.use('*', async (event, next) => {
    try {
      logger.send(ctx);
      await next();
    } catch (error: any) {
      logger.error(error);
      logger.send(ctx);
      return event.json(
        {
          message: 'Server error',
        },
        500,
      );
    }
  });
  // Register CORS middleware
  app.use('*', async (event, next) => {
    await next();
    event.res.headers.set(
      'Access-Control-Allow-Origin',
      event.req.header('origin') ?? '*',
    );
    event.res.headers.set('Access-Control-Max-Age', '86400');
    event.res.headers.set(
      'Access-Control-Allow-Methods',
      'GET, PATCH, POST, PUT, DELETE, OPTIONS, HEAD',
    );
    event.res.headers.set(
      'Access-Control-Allow-Headers',
      'origin, content-type, accept, authorization, x-requested-with, x-datadog-trace-id, x-datadog-parent-id, x-datadog-origin, x-datadog-sampling-priority, x-datadog-sampled',
    );
  });

  // Register OPTIONS handler
  app.options('*', (event) => event.text(''));

  // Register User class init middleware
  app.use('*', async (event, next) => {
    try {
      event.env.User = new User(request, env, logger) as User;
      await event.env.User.init();
      await next();
    } catch (err) {
      logger.error(err, {
        user: event.env.User.info.id,
      });
      return event.json(
        {
          errors: {
            status: 401,
            title: 'You must be authenticated to access this resource',
          },
        },
        401,
      );
    }
  });

export async function constructRouter(
  request: Request,
  env: Bindings,
  logger: Logger,
  ctx: ExecutionContext,
): Promise<Hono<{ Bindings: Bindings }>> {
  const app = new Hono<{ Bindings: Bindings }>();

  // Register logging middleware
  app.use('*', async (event, next) => {
    try {
      logger.send(ctx);
      await next();
    } catch (error: any) {
      logger.error(error);
      logger.send(ctx);
      return event.json(
        {
          message: 'Server error',
        },
        500,
      );
    }
  });
  // Register CORS middleware
  app.use('*', async (event, next) => {
    await next();
    event.res.headers.set(
      'Access-Control-Allow-Origin',
      event.req.header('origin') ?? '*',
    );
    event.res.headers.set('Access-Control-Max-Age', '86400');
    event.res.headers.set(
      'Access-Control-Allow-Methods',
      'GET, PATCH, POST, PUT, DELETE, OPTIONS, HEAD',
    );
    event.res.headers.set(
      'Access-Control-Allow-Headers',
      'origin, content-type, accept, authorization, x-requested-with, x-datadog-trace-id, x-datadog-parent-id, x-datadog-origin, x-datadog-sampling-priority, x-datadog-sampled',
    );
  });

  // Register OPTIONS handler
  app.options('*', (event) => event.text(''));

  // Register User class init middleware
  app.use('*', async (event, next) => {
    try {
      event.env.User = new User(request, env, logger) as User;
      await event.env.User.init();
      await next();
    } catch (err) {
      logger.error(err, {
        user: event.env.User.info.id,
      });
      return event.json(
        {
          errors: {
            status: 401,
            title: 'You must be authenticated to access this resource',
          },
        },
        401,
      );
    }
  });

C

CemOP•8/8/24, 4:26 AM

And here is the index.ts

import { constructRouter } from './router';

export { Views } from './views';

export default {
  async fetch(
    request: Request,
    env: Bindings,
    ctx: ExecutionContext,
  ): Promise<Response> {
    // Setup logging to datadog
    const logger = new Logger(
      new DatadogLoggerProvider({
        apiKey: env.DD_API_KEY,
        applicationKey: env.DD_APP_KEY,
        environment: env.ENVIRONMENT,
      }),
    );

    // Construct router
    const app = await constructRouter(request, env, logger, ctx);

    return app.fetch(request, env, ctx);
  },
};

import { constructRouter } from './router';

export { Views } from './views';

export default {
  async fetch(
    request: Request,
    env: Bindings,
    ctx: ExecutionContext,
  ): Promise<Response> {
    // Setup logging to datadog
    const logger = new Logger(
      new DatadogLoggerProvider({
        apiKey: env.DD_API_KEY,
        applicationKey: env.DD_APP_KEY,
        environment: env.ENVIRONMENT,
      }),
    );

    // Construct router
    const app = await constructRouter(request, env, logger, ctx);

    return app.fetch(request, env, ctx);
  },
};

import { constructRouter } from './router';

export { Views } from './views';

export default {
  async fetch(
    request: Request,
    env: Bindings,
    ctx: ExecutionContext,
  ): Promise<Response> {
    // Setup logging to datadog
    const logger = new Logger(
      new DatadogLoggerProvider({
        apiKey: env.DD_API_KEY,
        applicationKey: env.DD_APP_KEY,
        environment: env.ENVIRONMENT,
      }),
    );

    // Construct router
    const app = await constructRouter(request, env, logger, ctx);

    return app.fetch(request, env, ctx);
  },
};

import { constructRouter } from './router';

export { Views } from './views';

export default {
  async fetch(
    request: Request,
    env: Bindings,
    ctx: ExecutionContext,
  ): Promise<Response> {
    // Setup logging to datadog
    const logger = new Logger(
      new DatadogLoggerProvider({
        apiKey: env.DD_API_KEY,
        applicationKey: env.DD_APP_KEY,
        environment: env.ENVIRONMENT,
      }),
    );

    // Construct router
    const app = await constructRouter(request, env, logger, ctx);

    return app.fetch(request, env, ctx);
  },
};

C

CemOP•8/9/24, 9:22 AM

@Hard@Work | R2 ?

H

Hard@Work•8/9/24, 9:27 AM

Sorry, I'm not sure what else it could be...

C

CemOP•8/9/24, 9:28 AM

well at least we're not missing something obvious!

C

CemOP•8/9/24, 9:28 AM

how can we progress from here?

F

flof.fly•9/8/25, 4:56 AM

how did you solve it?

Enterprise customer - cannot perform I/O error

Similar Threads

Similar Threads

Similar Threads