Actor this.identifier is not available during blockConcurrencyWhile

[zekronium]

Describe the bug
The examples and documentation in the code mentions that this.identifier should be available (not default) during blockConcurrencyWhile, but currently it always is default

To Reproduce
In both cases, the identifier is default.
whoami works correctly.

export class MyActor extends Actor<Env> {
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);

        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }


    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
    }

    async whoami(): Promise<string | undefined> {
        return this.identifier;
    }
}

[Brayden]

Thanks for raising an issue @zekronium!

I don't see in your code example where you're trying to set the identifier (namely missing the nameFromRequest implementation). Below is a full example of how I configure one to use a custom identifier and also the logs I get when running it. Let me know if you run the same code and see different results:

export class MyRPCActor extends Actor<Env> {
    static nameFromRequest(request: Request): Promise<string> {
        return Promise.resolve("hogwarts");
    }
    
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
    
        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }

    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
    }

    async fetch(request: Request): Promise<Response> {
        const actor = MyStorageActor.get('default');
        const result = await actor.add(3, 4);
        return new Response(`Answer = ${result}`);
    }
}
export default handler(MyRPCActor);

Logs:

Actor initialized:  hogwarts
ID:  hogwarts

[zekronium]

Oh, based of some examples, like here

actors/examples/playground/src/index.ts

Lines 103 to 117 in a4e2393

	export class MyRPCActor extends Actor<Env> {
	constructor(ctx: DurableObjectState, env: Env) {
	super(ctx, env);
	this.ctx.blockConcurrencyWhile(async () => {
	console.log('ID: ', this.identifier)
	});
	}
	async fetch(request: Request): Promise<Response> {
	const actor = MyStorageActor.get('default');
	const result = await actor.add(3, 4);
	return new Response(`Answer = ${result}`);
	}
	}

I was under the impression that MyActor.get("foobar") would have the identifier set as foobar, not default

I have also tried your example, and it does not work.

import { Actor, handler } from '../../../packages/core/src'
import {Env} from "actor-storage/test/test-worker";
import {DurableObjectState} from "@cloudflare/workers-types";

export class MyActor extends Actor<Env> {
    static nameFromRequest(request: Request): Promise<string> {
        const url = new URL(request.url);
        const id = url.searchParams.get('id') || 'test-default';
        console.log("using id "+id);
        return Promise.resolve(id);
    }

    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        console.log("in constructor "+this.identifier);
        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }


    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
    }

    async whoami(): Promise<string | undefined> {
        return this.identifier;
    }

    async fetch(request: Request): Promise<Response> {
        const actor = MyActor.get('default');
        const result = await actor.whoami();
        return new Response(`Answer = ${result}`);
    }
}

export default handler(MyActor);

With log output

using id test-default
in constructor default
Actor initialized:  default
ID:  default

I am on wrangler 4.33.1

[Brayden]

I think part of the problem in your logs is that your MyActor class has a fetch implementation that calls back into the actor with default as the value:

async fetch(request: Request): Promise<Response> {
    const actor = MyActor.get('default'); // <-- here, you're using "default"
    const result = await actor.whoami();
    return new Response(`Answer = ${result}`);
}

Might be worth using the onInit hook instead of constructor too, but just my 2c:

protected async onInit(): Promise<void> {
    super.onInit();
    console.log('Actor initialized: ', this.identifier);

    this.ctx.blockConcurrencyWhile(async () => {
        console.log('ID: ', this.identifier)
    });
}

[zekronium]

Even if I don't use default, it is still default.

import { Actor, handler } from '../../../packages/core/src'
import {Env} from "actor-storage/test/test-worker";
import {DurableObjectState} from "@cloudflare/workers-types";

export class MyActor extends Actor<Env> {
    static nameFromRequest(request: Request): Promise<string> {
        const url = new URL(request.url);
        const id = url.searchParams.get('id') || 'test-default';
        console.log("using id "+id);
        return Promise.resolve(id);
    }

    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        console.log("in constructor "+this.identifier);
        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }

    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
    }

    async whoami(): Promise<string | undefined> {
        return this.identifier;
    }

    async fetch(request: Request): Promise<Response> {
        console.log("in fetch");
        const id = await MyActor.nameFromRequest(request);
        console.log("fetching actor with id "+id);
        const actor = MyActor.get(id);
        const result = await actor.whoami();
        return new Response(`Answer = ${result}`);
    }
}

export default handler(MyActor);

Even this with everything, the constructor is always default no matter what:

using id 13
in constructor default
Actor initialized:  default
ID:  default
in fetch
using id 13
fetching actor with id 13
result = 13

Now using a separate fetch handler

export class MyActor extends Actor<Env> {
    static nameFromRequest(request: Request): Promise<string> {
        const url = new URL(request.url);
        const id = url.searchParams.get('id') || 'test-default';
        console.log("using id "+id);
        return Promise.resolve(id);
    }

    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        console.log("in constructor "+this.identifier);
        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }

    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
    }

    async whoami(): Promise<string | undefined> {
        return this.identifier;
    }
}

export default {
    async fetch(request, env, ctx) {
        let actor = MyActor.get("test-1");
        let result = await actor.whoami();
        console.log("result = "+result);
        return new Response(result)
    }
}

Its still default in constructor

in constructor default
Actor initialized:  default
ID:  default
result = test-1

I also moved the blockConcurrencyWhile to onInit which made no difference:

    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.identifier);
        this.ctx.blockConcurrencyWhile(async () => {
            console.log('ID: ', this.identifier)
        });
    }

in constructor default
Actor initialized:  default
ID:  default
result = test-1

[Brayden]

You're right @zekronium. Instead of using the fetch and constructor methods I'd defer to using the onRequest and onInit as direct replacements. These are called in the correct sequence once the name is available to the instance.

Example:

export class MyActor extends Actor<Env> {
    static nameFromRequest(request: Request): Promise<string> {
        const url = new URL(request.url);
        const id = url.searchParams.get('id') || 'test-default';
        console.log("using id "+id);
        return Promise.resolve(id);
    }

    protected async onInit(): Promise<void> {
        super.onInit();
        console.log('Actor initialized: ', this.name);
    }

    protected async onRequest(request: Request): Promise<Response> {
        console.log('onRequest: ', this.name)
        const id = await MyActor.nameFromRequest(request);
        console.log("fetching actor with id "+id);
        const actor = MyActor.get(id);
        const result = await actor.whoami();
        return new Response(`Answer = ${result}`);
    }

    async whoami(): Promise<string | undefined> {
        return this.name;
    }
}

export default handler(MyActor);

I'll update the docs to remove any reference of it being possible there until we're able to provide it again to the constructor. Let me know if the onInit and onRequest methods don't meet your needs for any reason.