pkgs/appengine/lib/src/appengine_internal.dart - labs - Git at Google

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.


 import 'dart:async';
 import 'dart:io';

 import 'package:gcloud/datastore.dart' as datastore;
 import 'package:gcloud/db.dart' as db;
 import 'package:gcloud/http.dart' as gcloud_http;
 import 'package:gcloud/service_scope.dart' as ss;
 import 'package:gcloud/storage.dart' as storage;
 import 'package:googleapis_auth/auth_io.dart' as auth;
 import 'package:grpc/grpc.dart' as grpc;
 import 'package:grpc/src/client/connection.dart';
 import 'package:http/http.dart' as http;
 import 'package:path/path.dart' as p;

 import 'api_impl/stderr_logging_impl.dart' as stderr_logging_impl;
 import 'appengine_context.dart';
 import 'client_context.dart';
 import 'grpc_api_impl/datastore_impl.dart' as grpc_datastore_impl;
 import 'grpc_api_impl/logging_impl.dart' as grpc_logging_impl;
 import 'logging.dart' as logging;
 import 'logging_impl.dart';
 import 'server/context_registry.dart';
 import 'server/logging_package_adaptor.dart';
 import 'server/server.dart';

 bool _loggingPackageEnabled = false;

 /// Runs the given [callback] inside a new service scope and makes AppEngine
 /// services available within that scope.
 Future withAppEngineServices(Future Function() callback) =>
     _withAppEngineServicesInternal((_) => callback());

 /// Runs the AppEngine http server and uses the given request [handler] to
 /// handle incoming http requests.
 ///
 /// The given request [handler] is run inside a new service scope and has all
 /// AppEngine services available within that scope.
 Future runAppEngine(
   void Function(HttpRequest request, ClientContext context) handler,
   void Function(Object e, StackTrace s)? onError, {
   int port = 8080,
   bool shared = false,
   void Function(InternetAddress address, int port)? onAcceptingConnections,
 }) {
   return _withAppEngineServicesInternal((ContextRegistry contextRegistry) {
     final appengineServer = AppEngineHttpServer(contextRegistry,
         port: port, shared: shared)
       ..run((request, context) {
         ss.fork(() {
           logging.registerLoggingService(context.services.logging);
           handler(request, context);
           return request.response.done;
         }, onError: (error, stack) {
           final context = contextRegistry.lookup(request);
           if (context != null) {
             try {
               context.services.logging
                   .error('Uncaught error in request handler: $error\n$stack');
             } catch (e) {
               print('Error while logging uncaught error: $e.'
                   'Original error: $error\n$stack');
             }
           } else {
             print('Unable to log error, since response has already been sent'
                 'Original error: $error\n$stack');
           }
           if (onError != null) {
             onError('Uncaught error in request handler zone: $error', stack);
           }

           // In many cases errors happen during request processing or response
           // preparation. In such cases we want to close the connection, since
           // user code might not be able to.
           try {
             request.response.statusCode = HttpStatus.internalServerError;
           } on StateError catch (_) {}
           request.response.close().catchError((closeError, closeErrorStack) {
             final message =
                 'Forcefully closing response, due to error in request'
                 ' handler zone, resulted in an error: $closeError';
             if (onError != null) {
               onError(message, closeErrorStack);
             } else {
               print('$message\n$closeErrorStack');
             }
           });
         });
       }, onAcceptingConnections: onAcceptingConnections);
     return appengineServer.done;
   });
 }

 Future _withAppEngineServicesInternal(
     Future Function(ContextRegistry contextRegistry) callback) {
   return ss.fork(() async {
     final ContextRegistry contextRegistry = await _initializeAppEngine();
     final bgServices = contextRegistry.newBackgroundServices();

     db.registerDbService(bgServices.db);
     datastore.registerDatastoreService(bgServices.db.datastore);
     storage.registerStorageService(bgServices.storage);
     logging.registerLoggingService(bgServices.logging);

     return callback(contextRegistry);
   });
 }

 /// Sets up a `package:logging` adaptor to use AppEngine logging service.
 ///
 /// The logging messages made via `package:logging` which are made inside a
 /// request handler will end up grouped together in an AppEngine logging entry.
 void useLoggingPackageAdaptor() {
   if (_loggingPackageEnabled) return;
   _loggingPackageEnabled = true;
   setupAppEngineLogging();
 }

 /// Uses various environment variables to initialize the appengine services and
 /// returns a new [ContextRegistry] which is used for registering in-progress
 /// http requests.
 Future<ContextRegistry> _initializeAppEngine() async {
   var zoneId = await _getZoneInProduction();
   final isDevEnvironment = zoneId == null;
   zoneId ??= 'dev-machine';
   final bool isProdEnvironment = !isDevEnvironment;

   String? findEnvironmentVariable(String name,
       {bool onlyInProd = false, bool onlyInDev = false, bool needed = true}) {
     if (onlyInProd && !isProdEnvironment) return null;
     if (onlyInDev && !isDevEnvironment) return null;

     final value = Platform.environment[name];
     if (value == null && needed) {
       throw StateError('Expected environment variable $name to be set!');
     }
     return value;
   }

   final projectId = findEnvironmentVariable(
     'GOOGLE_CLOUD_PROJECT',
     needed: true,
   )!;

   // For local testing the gcloud sdk brings now a gRPC-ready datastore
   // emulator which will tell the user to use this environment variable.
   final dbEmulatorHost = findEnvironmentVariable('DATASTORE_EMULATOR_HOST',
       onlyInDev: false, needed: false);

   final serviceId =
       findEnvironmentVariable('GAE_SERVICE', onlyInProd: true, needed: true) ??
           'dummy-service';
   final versionId =
       findEnvironmentVariable('GAE_VERSION', onlyInProd: true, needed: true) ??
           'dummy-version';
   final instance = findEnvironmentVariable('GAE_INSTANCE',
           onlyInProd: true, needed: true) ??
       'dummy-instance';

   final String? pubServeUrlString = Platform.environment['DART_PUB_SERVE'];
   final Uri? pubServeUrl =
       pubServeUrlString != null ? Uri.parse(pubServeUrlString) : null;

   final instanceId = await _getInstanceid();

   final context = AppEngineContext(isDevEnvironment, projectId, versionId,
       serviceId, instance, instanceId, pubServeUrl);

   final loggerFactory = await _obtainLoggerFactory(context, zoneId);
   final storageService = await _obtainStorageService(context.applicationID);

   final dbService = await _obtainDatastoreService(
     context.applicationID,
     dbEmulatorHost,
   );

   // Setup a default authClient for package:gcloud
   gcloud_http.registerAuthClientService(
       await auth.clientViaApplicationDefaultCredentials(
     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
   ));

   return ContextRegistry(loggerFactory, dbService, storageService, context);
 }

 /// Obtains a gRPC-based datastore implementation.
 ///
 /// If [dbEmulatorHost] is not null it must have the form 'host:port' and
 /// support http/2-based unencrypted gRPC.
 ///
 /// Otherwise http2/-based encrypted gRPC will be used to Google's production
 /// service.
 ///
 /// The datastore emulator comes with the gcloud sdk and can be launched via:
 ///
 ///     $ gcloud beta emulators datastore start
 ///       ...
 ///       [datastore] If you are using a library that supports the
 ///                   DATASTORE_EMULATOR_HOST environment variable, run:
 ///       [datastore]
 ///       [datastore]   export DATASTORE_EMULATOR_HOST=localhost:8037
 ///       [datastore]
 ///       [datastore] Dev App Server is now running.
 ///       ...
 ///
 /// The returned [db.DatastoreDB] will be usable within the current service
 /// scope.
 Future<db.DatastoreDB> _obtainDatastoreService(
   String projectId,
   String? dbEmulatorHost,
 ) async {
   String endpoint = 'https://datastore.googleapis.com';
   bool needAuthorization = true;
   if (dbEmulatorHost != null && dbEmulatorHost.contains(':')) {
     // The datastore emulator uses unencrypted http/2, we use therefore 'http'
     // for the uri scheme.
     endpoint = 'http://$dbEmulatorHost';
     needAuthorization = false;
   }
   final authenticator = await grpc.applicationDefaultCredentialsAuthenticator(
     grpc_datastore_impl.OAuth2Scopes,
   );
   final grpcClient = _getGrpcClientChannel(endpoint, needAuthorization);
   final rawDatastore = datastore.Datastore.withRetry(
     grpc_datastore_impl.GrpcDatastoreImpl(
       grpcClient,
       authenticator,
       projectId,
     ),
   );
   return db.DatastoreDB(rawDatastore, modelDB: db.ModelDBImpl());
 }

 /// Creates a storage service using the service account credentials (if given)
 /// or using the metadata to obtain access credentials.
 Future<storage.Storage> _obtainStorageService(String projectId) async {
   final authClient = await auth.clientViaApplicationDefaultCredentials(
     scopes: storage.Storage.SCOPES,
   );
   return storage.Storage(authClient, projectId);
 }

 /// Creates a closure function which can be used for
 ///
 /// The underlying logging implementation will be usable within the current
 /// service scope.
 Future<LoggerFactory> _obtainLoggerFactory(
   AppEngineContext context,
   String zoneId,
 ) async {
   if (context.isDevelopmentEnvironment) {
     return StderrLoggerFactory();
   } else {
     final authenticator = await grpc.applicationDefaultCredentialsAuthenticator(
       grpc_logging_impl.OAuth2Scopes,
     );
     final sharedLoggingService = grpc_logging_impl.SharedLoggingService(
         _getGrpcClientChannel('https://logging.googleapis.com', true),
         authenticator,
         context.applicationID,
         context.module,
         context.version,
         zoneId,
         context.instance,
         context.instanceId);
     ss.registerScopeExitCallback(sharedLoggingService.close);
     return GrpcLoggerFactory(sharedLoggingService);
   }
 }

 /// Creates a grpc client to the specified host using service account
 /// credentials for authorization.
 ///
 /// The returned [grpc.Client] will be usable within the current service scope.
 grpc.ClientChannel _getGrpcClientChannel(String url, bool needAuthorization) {
   final clientChannel = _ClientChannelWithClientId(grpc.ClientChannel(
     Uri.parse(url).host,
     options: needAuthorization
         ? grpc.ChannelOptions()
         : grpc.ChannelOptions(
             credentials: grpc.ChannelCredentials.insecure(),
           ),
   ));
   ss.registerScopeExitCallback(clientChannel.shutdown);
   return clientChannel;
 }

 /// Major.minor.patch version of the current Dart SDK.
 final _dartVersion = Platform.version.split(RegExp('[^0-9]')).take(3).join('.');

 /// Wraps [grpc.ClientChannel] attaching a client id header to each request.
 class _ClientChannelWithClientId implements grpc.ClientChannel {
   final grpc.ClientChannel _clientChannel;
   _ClientChannelWithClientId(this._clientChannel);

   @override
   grpc.ClientCall<Q, R> createCall<Q, R>(
     grpc.ClientMethod<Q, R> method,
     Stream<Q> requests,
     grpc.CallOptions options,
   ) =>
       _clientChannel.createCall<Q, R>(
         method,
         requests,
         grpc.CallOptions(metadata: {
           'x-goog-api-client': 'gl-dart/$_dartVersion',
         }).mergedWith(options),
       );

   @override
   ClientConnection createConnection() => _clientChannel.createConnection();

   @override
   Future<ClientConnection> getConnection() => _clientChannel.getConnection();

   @override
   String get host => _clientChannel.host as String;

   @override
   grpc.ChannelOptions get options => _clientChannel.options;

   @override
   int get port => _clientChannel.port;

   @override
   Future<void> shutdown() => _clientChannel.shutdown();

   @override
   Future<void> terminate() => _clientChannel.terminate();

   @override
   Stream<ConnectionState> get onConnectionStateChanged =>
       _clientChannel.onConnectionStateChanged;
 }

 Future<String?> _getZoneInProduction() => _getMetadataValue('zone');

 Future<String?> _getInstanceid() => _getMetadataValue('id');

 Future<String?> _getMetadataValue(String path) async {
   final client = http.Client();
   try {
     final response = await client.get(
         Uri.parse(
             'http://metadata.google.internal/computeMetadata/v1/instance/$path'),
         headers: {
           'Metadata-Flavor': 'Google',
         });
     if (response.statusCode == HttpStatus.ok) {
       if (response.headers[HttpHeaders.contentTypeHeader]!.contains('html') ||
           response.body.contains('<html>')) {
         // The response is not expected to be HTML. This likely means we're not
         // running on cloud, and the request was intercepted by an HTTP proxy.
         return null;
       }
       return p.split(response.body).last;
     }

     throw Exception([
       'Reqeust for metadata returned something unexpected',
       response.statusCode,
       response.body
     ].join('\n'));
   } on SocketException {
     // likely not on cloud
     return null;
   } catch (e) {
     stderr.writeln('Unexpected error when trying to access metadata');
     rethrow;
   } finally {
     client.close();
   }
 }

 /// Factory used for creating request-specific and background loggers.
 ///
 /// The implementation sends log messages to the Stackdriver logging service via
 /// gRPC.
 class GrpcLoggerFactory implements LoggerFactory {
   final grpc_logging_impl.SharedLoggingService _shared;

   GrpcLoggerFactory(this._shared);

   @override
   LoggingImpl newRequestSpecificLogger(
       String method,
       String resource,
       String userAgent,
       String host,
       String ip,
       String? traceId,
       String referrer) {
     return grpc_logging_impl.GrpcRequestLoggingImpl(
         _shared, method, resource, userAgent, host, ip, traceId, referrer);
   }

   @override
   logging.Logging newBackgroundLogger() {
     return grpc_logging_impl.GrpcBackgroundLoggingImpl(_shared);
   }
 }

 /// Factory used for creating request-specific and background loggers.
 ///
 /// The implementation writes log messages to stderr.
 class StderrLoggerFactory implements LoggerFactory {
   @override
   LoggingImpl newRequestSpecificLogger(
       String method,
       String resource,
       String userAgent,
       String host,
       String ip,
       String? traceId,
       String referrer) {
     return stderr_logging_impl.StderrRequestLoggingImpl(method, resource);
   }

   @override
   logging.Logging newBackgroundLogger() {
     return stderr_logging_impl.StderrBackgroundLoggingImpl();
   }
 }
	// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.


	import 'dart:async';
	import 'dart:io';

	import 'package:gcloud/datastore.dart' as datastore;
	import 'package:gcloud/db.dart' as db;
	import 'package:gcloud/http.dart' as gcloud_http;
	import 'package:gcloud/service_scope.dart' as ss;
	import 'package:gcloud/storage.dart' as storage;
	import 'package:googleapis_auth/auth_io.dart' as auth;
	import 'package:grpc/grpc.dart' as grpc;
	import 'package:grpc/src/client/connection.dart';
	import 'package:http/http.dart' as http;
	import 'package:path/path.dart' as p;

	import 'api_impl/stderr_logging_impl.dart' as stderr_logging_impl;
	import 'appengine_context.dart';
	import 'client_context.dart';
	import 'grpc_api_impl/datastore_impl.dart' as grpc_datastore_impl;
	import 'grpc_api_impl/logging_impl.dart' as grpc_logging_impl;
	import 'logging.dart' as logging;
	import 'logging_impl.dart';
	import 'server/context_registry.dart';
	import 'server/logging_package_adaptor.dart';
	import 'server/server.dart';

	bool _loggingPackageEnabled = false;

	/// Runs the given [callback] inside a new service scope and makes AppEngine
	/// services available within that scope.
	Future withAppEngineServices(Future Function() callback) =>
	_withAppEngineServicesInternal((_) => callback());

	/// Runs the AppEngine http server and uses the given request [handler] to
	/// handle incoming http requests.
	///
	/// The given request [handler] is run inside a new service scope and has all
	/// AppEngine services available within that scope.
	Future runAppEngine(
	void Function(HttpRequest request, ClientContext context) handler,
	void Function(Object e, StackTrace s)? onError, {
	int port = 8080,
	bool shared = false,
	void Function(InternetAddress address, int port)? onAcceptingConnections,
	}) {
	return _withAppEngineServicesInternal((ContextRegistry contextRegistry) {
	final appengineServer = AppEngineHttpServer(contextRegistry,
	port: port, shared: shared)
	..run((request, context) {
	ss.fork(() {
	logging.registerLoggingService(context.services.logging);
	handler(request, context);
	return request.response.done;
	}, onError: (error, stack) {
	final context = contextRegistry.lookup(request);
	if (context != null) {
	try {
	context.services.logging
	.error('Uncaught error in request handler: $error\n$stack');
	} catch (e) {
	print('Error while logging uncaught error: $e.'
	'Original error: $error\n$stack');
	}
	} else {
	print('Unable to log error, since response has already been sent'
	'Original error: $error\n$stack');
	}
	if (onError != null) {
	onError('Uncaught error in request handler zone: $error', stack);
	}

	// In many cases errors happen during request processing or response
	// preparation. In such cases we want to close the connection, since
	// user code might not be able to.
	try {
	request.response.statusCode = HttpStatus.internalServerError;
	} on StateError catch (_) {}
	request.response.close().catchError((closeError, closeErrorStack) {
	final message =
	'Forcefully closing response, due to error in request'
	' handler zone, resulted in an error: $closeError';
	if (onError != null) {
	onError(message, closeErrorStack);
	} else {
	print('$message\n$closeErrorStack');
	}
	});
	});
	}, onAcceptingConnections: onAcceptingConnections);
	return appengineServer.done;
	});
	}

	Future _withAppEngineServicesInternal(
	Future Function(ContextRegistry contextRegistry) callback) {
	return ss.fork(() async {
	final ContextRegistry contextRegistry = await _initializeAppEngine();
	final bgServices = contextRegistry.newBackgroundServices();

	db.registerDbService(bgServices.db);
	datastore.registerDatastoreService(bgServices.db.datastore);
	storage.registerStorageService(bgServices.storage);
	logging.registerLoggingService(bgServices.logging);

	return callback(contextRegistry);
	});
	}

	/// Sets up a `package:logging` adaptor to use AppEngine logging service.
	///
	/// The logging messages made via `package:logging` which are made inside a
	/// request handler will end up grouped together in an AppEngine logging entry.
	void useLoggingPackageAdaptor() {
	if (_loggingPackageEnabled) return;
	_loggingPackageEnabled = true;
	setupAppEngineLogging();
	}

	/// Uses various environment variables to initialize the appengine services and
	/// returns a new [ContextRegistry] which is used for registering in-progress
	/// http requests.
	Future<ContextRegistry> _initializeAppEngine() async {
	var zoneId = await _getZoneInProduction();
	final isDevEnvironment = zoneId == null;
	zoneId ??= 'dev-machine';
	final bool isProdEnvironment = !isDevEnvironment;

	String? findEnvironmentVariable(String name,
	{bool onlyInProd = false, bool onlyInDev = false, bool needed = true}) {
	if (onlyInProd && !isProdEnvironment) return null;
	if (onlyInDev && !isDevEnvironment) return null;

	final value = Platform.environment[name];
	if (value == null && needed) {
	throw StateError('Expected environment variable $name to be set!');
	}
	return value;
	}

	final projectId = findEnvironmentVariable(
	'GOOGLE_CLOUD_PROJECT',
	needed: true,
	)!;

	// For local testing the gcloud sdk brings now a gRPC-ready datastore
	// emulator which will tell the user to use this environment variable.
	final dbEmulatorHost = findEnvironmentVariable('DATASTORE_EMULATOR_HOST',
	onlyInDev: false, needed: false);

	final serviceId =
	findEnvironmentVariable('GAE_SERVICE', onlyInProd: true, needed: true) ??
	'dummy-service';
	final versionId =
	findEnvironmentVariable('GAE_VERSION', onlyInProd: true, needed: true) ??
	'dummy-version';
	final instance = findEnvironmentVariable('GAE_INSTANCE',
	onlyInProd: true, needed: true) ??
	'dummy-instance';

	final String? pubServeUrlString = Platform.environment['DART_PUB_SERVE'];
	final Uri? pubServeUrl =
	pubServeUrlString != null ? Uri.parse(pubServeUrlString) : null;

	final instanceId = await _getInstanceid();

	final context = AppEngineContext(isDevEnvironment, projectId, versionId,
	serviceId, instance, instanceId, pubServeUrl);

	final loggerFactory = await _obtainLoggerFactory(context, zoneId);
	final storageService = await _obtainStorageService(context.applicationID);

	final dbService = await _obtainDatastoreService(
	context.applicationID,
	dbEmulatorHost,
	);

	// Setup a default authClient for package:gcloud
	gcloud_http.registerAuthClientService(
	await auth.clientViaApplicationDefaultCredentials(
	scopes: ['https://www.googleapis.com/auth/cloud-platform'],
	));

	return ContextRegistry(loggerFactory, dbService, storageService, context);
	}

	/// Obtains a gRPC-based datastore implementation.
	///
	/// If [dbEmulatorHost] is not null it must have the form 'host:port' and
	/// support http/2-based unencrypted gRPC.
	///
	/// Otherwise http2/-based encrypted gRPC will be used to Google's production
	/// service.
	///
	/// The datastore emulator comes with the gcloud sdk and can be launched via:
	///
	/// $ gcloud beta emulators datastore start
	/// ...
	/// [datastore] If you are using a library that supports the
	/// DATASTORE_EMULATOR_HOST environment variable, run:
	/// [datastore]
	/// [datastore] export DATASTORE_EMULATOR_HOST=localhost:8037
	/// [datastore]
	/// [datastore] Dev App Server is now running.
	/// ...
	///
	/// The returned [db.DatastoreDB] will be usable within the current service
	/// scope.
	Future<db.DatastoreDB> _obtainDatastoreService(
	String projectId,
	String? dbEmulatorHost,
	) async {
	String endpoint = 'https://datastore.googleapis.com';
	bool needAuthorization = true;
	if (dbEmulatorHost != null && dbEmulatorHost.contains(':')) {
	// The datastore emulator uses unencrypted http/2, we use therefore 'http'
	// for the uri scheme.
	endpoint = 'http://$dbEmulatorHost';
	needAuthorization = false;
	}
	final authenticator = await grpc.applicationDefaultCredentialsAuthenticator(
	grpc_datastore_impl.OAuth2Scopes,
	);
	final grpcClient = _getGrpcClientChannel(endpoint, needAuthorization);
	final rawDatastore = datastore.Datastore.withRetry(
	grpc_datastore_impl.GrpcDatastoreImpl(
	grpcClient,
	authenticator,
	projectId,
	),
	);
	return db.DatastoreDB(rawDatastore, modelDB: db.ModelDBImpl());
	}

	/// Creates a storage service using the service account credentials (if given)
	/// or using the metadata to obtain access credentials.
	Future<storage.Storage> _obtainStorageService(String projectId) async {
	final authClient = await auth.clientViaApplicationDefaultCredentials(
	scopes: storage.Storage.SCOPES,
	);
	return storage.Storage(authClient, projectId);
	}

	/// Creates a closure function which can be used for
	///
	/// The underlying logging implementation will be usable within the current
	/// service scope.
	Future<LoggerFactory> _obtainLoggerFactory(
	AppEngineContext context,
	String zoneId,
	) async {
	if (context.isDevelopmentEnvironment) {
	return StderrLoggerFactory();
	} else {
	final authenticator = await grpc.applicationDefaultCredentialsAuthenticator(
	grpc_logging_impl.OAuth2Scopes,
	);
	final sharedLoggingService = grpc_logging_impl.SharedLoggingService(
	_getGrpcClientChannel('https://logging.googleapis.com', true),
	authenticator,
	context.applicationID,
	context.module,
	context.version,
	zoneId,
	context.instance,
	context.instanceId);
	ss.registerScopeExitCallback(sharedLoggingService.close);
	return GrpcLoggerFactory(sharedLoggingService);
	}
	}

	/// Creates a grpc client to the specified host using service account
	/// credentials for authorization.
	///
	/// The returned [grpc.Client] will be usable within the current service scope.
	grpc.ClientChannel _getGrpcClientChannel(String url, bool needAuthorization) {
	final clientChannel = _ClientChannelWithClientId(grpc.ClientChannel(
	Uri.parse(url).host,
	options: needAuthorization
	? grpc.ChannelOptions()
	: grpc.ChannelOptions(
	credentials: grpc.ChannelCredentials.insecure(),
	),
	));
	ss.registerScopeExitCallback(clientChannel.shutdown);
	return clientChannel;
	}

	/// Major.minor.patch version of the current Dart SDK.
	final _dartVersion = Platform.version.split(RegExp('[^0-9]')).take(3).join('.');

	/// Wraps [grpc.ClientChannel] attaching a client id header to each request.
	class _ClientChannelWithClientId implements grpc.ClientChannel {
	final grpc.ClientChannel _clientChannel;
	_ClientChannelWithClientId(this._clientChannel);

	@override
	grpc.ClientCall<Q, R> createCall<Q, R>(
	grpc.ClientMethod<Q, R> method,
	Stream<Q> requests,
	grpc.CallOptions options,
	) =>
	_clientChannel.createCall<Q, R>(
	method,
	requests,
	grpc.CallOptions(metadata: {
	'x-goog-api-client': 'gl-dart/$_dartVersion',
	}).mergedWith(options),
	);

	@override
	ClientConnection createConnection() => _clientChannel.createConnection();

	@override
	Future<ClientConnection> getConnection() => _clientChannel.getConnection();

	@override
	String get host => _clientChannel.host as String;

	@override
	grpc.ChannelOptions get options => _clientChannel.options;

	@override
	int get port => _clientChannel.port;

	@override
	Future<void> shutdown() => _clientChannel.shutdown();

	@override
	Future<void> terminate() => _clientChannel.terminate();

	@override
	Stream<ConnectionState> get onConnectionStateChanged =>
	_clientChannel.onConnectionStateChanged;
	}

	Future<String?> _getZoneInProduction() => _getMetadataValue('zone');

	Future<String?> _getInstanceid() => _getMetadataValue('id');

	Future<String?> _getMetadataValue(String path) async {
	final client = http.Client();
	try {
	final response = await client.get(
	Uri.parse(
	'http://metadata.google.internal/computeMetadata/v1/instance/$path'),
	headers: {
	'Metadata-Flavor': 'Google',
	});
	if (response.statusCode == HttpStatus.ok) {
	if (response.headers[HttpHeaders.contentTypeHeader]!.contains('html') \|\|
	response.body.contains('<html>')) {
	// The response is not expected to be HTML. This likely means we're not
	// running on cloud, and the request was intercepted by an HTTP proxy.
	return null;
	}
	return p.split(response.body).last;
	}

	throw Exception([
	'Reqeust for metadata returned something unexpected',
	response.statusCode,
	response.body
	].join('\n'));
	} on SocketException {
	// likely not on cloud
	return null;
	} catch (e) {
	stderr.writeln('Unexpected error when trying to access metadata');
	rethrow;
	} finally {
	client.close();
	}
	}

	/// Factory used for creating request-specific and background loggers.
	///
	/// The implementation sends log messages to the Stackdriver logging service via
	/// gRPC.
	class GrpcLoggerFactory implements LoggerFactory {
	final grpc_logging_impl.SharedLoggingService _shared;

	GrpcLoggerFactory(this._shared);

	@override
	LoggingImpl newRequestSpecificLogger(
	String method,
	String resource,
	String userAgent,
	String host,
	String ip,
	String? traceId,
	String referrer) {
	return grpc_logging_impl.GrpcRequestLoggingImpl(
	_shared, method, resource, userAgent, host, ip, traceId, referrer);
	}

	@override
	logging.Logging newBackgroundLogger() {
	return grpc_logging_impl.GrpcBackgroundLoggingImpl(_shared);
	}
	}

	/// Factory used for creating request-specific and background loggers.
	///
	/// The implementation writes log messages to stderr.
	class StderrLoggerFactory implements LoggerFactory {
	@override
	LoggingImpl newRequestSpecificLogger(
	String method,
	String resource,
	String userAgent,
	String host,
	String ip,
	String? traceId,
	String referrer) {
	return stderr_logging_impl.StderrRequestLoggingImpl(method, resource);
	}

	@override
	logging.Logging newBackgroundLogger() {
	return stderr_logging_impl.StderrBackgroundLoggingImpl();
	}
	}