Method register

lambda-extension/src/extension.rs:246–351

Register the extension. Performs the [init phase](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html#runtimes-lifecycle-ib) Lambda lifecycle operations to register the extension. When implementing an internal Lambda extension, it is safe to call `lambda_runtime::run` once the future returned by this function resolves.

(self)

    /// extension, it is safe to call `lambda_runtime::run` once the future returned by this
    /// function resolves.
    pub async fn register(self) -> Result<RegisteredExtension<E>, Error> {
        let client = &Client::builder().build()?;

        let register_res = register(client, self.extension_name, self.events).await?;

        // Logs API subscriptions must be requested during the Lambda init phase (see
        // https://docs.aws.amazon.com/lambda/latest/dg/runtimes-logs-api.html#runtimes-logs-api-subscribing).
        if let Some(mut log_processor) = self.logs_processor {
            trace!("Log processor found");

            validate_buffering_configuration(self.log_buffering)?;

            let addr = SocketAddr::from(([0, 0, 0, 0], self.log_port_number));
            let service = log_processor.make_service(());
            let service = Arc::new(Mutex::new(service.await.unwrap()));
            tokio::task::spawn(async move {
                trace!("Creating new logs processor Service");

                loop {
                    let service: Arc<Mutex<_>> = service.clone();
                    let make_service = service_fn(move |req: Request<Incoming>| log_wrapper(service.clone(), req));

                    let listener = TcpListener::bind(addr).await.unwrap();
                    let (tcp, _) = listener.accept().await.unwrap();
                    let io = TokioIo::new(tcp);
                    tokio::task::spawn(async move {
                        if let Err(err) = http1::Builder::new().serve_connection(io, make_service).await {
                            println!("Error serving connection: {err:?}");
                        }
                    });
                }
            });

            trace!("Log processor started");

            // Call Logs API to start receiving events
            let req = requests::subscribe_request(
                Api::LogsApi,
                &register_res.extension_id,
                self.log_types,
                self.log_buffering,
                self.log_port_number,
            )?;
            let res = client.call(req).await?;
            if !res.status().is_success() {
                let err = format!("unable to initialize the logs api: {}", res.status());
                return Err(ExtensionError::boxed(err));
            }
            trace!("Registered extension with Logs API");
        }

        // Telemetry API subscriptions must be requested during the Lambda init phase (see
        // https://docs.aws.amazon.com/lambda/latest/dg/telemetry-api.html#telemetry-api-registration
        if let Some(mut telemetry_processor) = self.telemetry_processor {
            trace!("Telemetry processor found");

            validate_buffering_configuration(self.telemetry_buffering)?;