@contentful/optimization-api-client 0.1.0-alpha8 → 1.0.0

package/dist/index.cjs

@@ -1,564 +1,38 @@
 "use strict";
 var __webpack_modules__ = {
-    "./src/ApiClient.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./src/lib/logger/LogSink.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            A: ()=>ApiClient
+            A: ()=>__rspack_default_export
         });
-        var _experience__rspack_import_0 = __webpack_require__("./src/experience/index.ts");
-        var _insights__rspack_import_1 = __webpack_require__("./src/insights/index.ts");
-        class ApiClient {
-            config;
-            experience;
-            insights;
-            constructor(config){
-                const { personalization, analytics, ...apiConfig } = config;
-                this.config = apiConfig;
-                this.experience = new _experience__rspack_import_0.A({
-                    ...apiConfig,
-                    ...personalization
-                });
-                this.insights = new _insights__rspack_import_1.A({
-                    ...apiConfig,
-                    ...analytics
-                });
-            }
-        }
-    },
-    "./src/ApiClientBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>src_ApiClientBase
-        });
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        const external_p_retry_namespaceObject = require("p-retry");
-        var external_p_retry_default = /*#__PURE__*/ __webpack_require__.n(external_p_retry_namespaceObject);
-        const logger = (0, dist.zP)('ApiClient:Retry');
-        const DEFAULT_INTERVAL_TIMEOUT = 0;
-        const DEFAULT_RETRY_COUNT = 1;
-        const RETRY_RESPONSE_STATUS = 503;
-        const HTTP_ERROR_RESPONSE_STATUS = 500;
-        class HttpError extends Error {
-            status;
-            constructor(message, status = HTTP_ERROR_RESPONSE_STATUS){
-                super(message);
-                Object.setPrototypeOf(this, HttpError.prototype);
-                this.status = status;
-            }
-        }
-        function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod = fetch, init, url }) {
-            return async ()=>{
-                try {
-                    const response = await fetchMethod(url, init);
-                    if (response.status === RETRY_RESPONSE_STATUS) throw new HttpError(`${apiName} API request to "${url.toString()}" failed with status: "[${response.status}] ${response.statusText}".`, RETRY_RESPONSE_STATUS);
-                    if (!response.ok) {
-                        const httpError = new Error(`Request to "${url.toString()}" failed with status: [${response.status}] ${response.statusText} - traceparent: ${response.headers.get('traceparent')}`);
-                        logger.error('Request failed with non-OK status:', httpError);
-                        controller.abort();
-                        return;
-                    }
-                    logger.debug(`Response from "${url.toString()}":`, response);
-                    return response;
-                } catch (error) {
-                    if (error instanceof HttpError && error.status === RETRY_RESPONSE_STATUS) throw error;
-                    logger.error(`Request to "${url.toString()}" failed:`, error);
-                    controller.abort();
-                }
-            };
-        }
-        function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
-            return async (url, init)=>{
-                const controller = new AbortController();
-                let retryResponse;
-                try {
-                    retryResponse = await external_p_retry_default()(createRetryFetchCallback({
-                        apiName,
-                        controller,
-                        fetchMethod,
-                        init,
-                        url
-                    }), {
-                        minTimeout: intervalTimeout,
-                        onFailedAttempt: (options)=>onFailedAttempt?.({
-                                ...options,
-                                apiName
-                            }),
-                        retries,
-                        signal: controller.signal
-                    });
-                } catch (error) {
-                    if (!(error instanceof Error) || 'AbortError' !== error.name) throw error;
-                }
-                if (!retryResponse) throw new Error(`${apiName} API request to "${url.toString()}" may not be retried.`);
-                return retryResponse;
-            };
-        }
-        const createTimeoutFetchMethod_logger = (0, dist.zP)('ApiClient:Timeout');
-        const DEFAULT_REQUEST_TIMEOUT = 3000;
-        function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
-            return async (url, init)=>{
-                const controller = new AbortController();
-                const id = setTimeout(()=>{
-                    if ('function' == typeof onRequestTimeout) onRequestTimeout({
-                        apiName
-                    });
-                    else createTimeoutFetchMethod_logger.error(`Request to "${url.toString()}" timed out`, new Error('Request timeout'));
-                    controller.abort();
-                }, requestTimeout);
-                const response = await fetchMethod(url, {
-                    ...init,
-                    signal: controller.signal
-                });
-                clearTimeout(id);
-                return response;
-            };
+        class LogSink {
         }
-        const createProtectedFetchMethod_logger = (0, dist.zP)('ApiClient:Fetch');
-        function createProtectedFetchMethod(options) {
-            try {
-                const timeoutFetchMethod = createTimeoutFetchMethod(options);
-                const retryFetchMethod = createRetryFetchMethod({
-                    ...options,
-                    fetchMethod: timeoutFetchMethod
-                });
-                return retryFetchMethod;
-            } catch (error) {
-                if (error instanceof Error) if ('AbortError' === error.name) createProtectedFetchMethod_logger.warn('Request aborted due to network issues. This request may not be retried.');
-                else createProtectedFetchMethod_logger.error('Request failed:', error);
-                throw error;
-            }
-        }
-        const Fetch = {
-            create: createProtectedFetchMethod
-        };
-        const fetch_Fetch = Fetch;
-        const src_fetch = fetch_Fetch;
-        const ApiClientBase_logger = (0, dist.zP)('ApiClient');
-        const DEFAULT_ENVIRONMENT = 'main';
-        class ApiClientBase {
-            name;
-            clientId;
-            environment;
-            fetch;
-            constructor(name, { fetchOptions, clientId, environment }){
-                this.clientId = clientId;
-                this.environment = environment ?? DEFAULT_ENVIRONMENT;
-                this.name = name;
-                this.fetch = src_fetch.create({
-                    ...fetchOptions ?? {},
-                    apiName: name
-                });
-            }
-            logRequestError(error, { requestName }) {
-                if (error instanceof Error) if ('AbortError' === error.name) ApiClientBase_logger.warn(`[${this.name}] "${requestName}" request aborted due to network issues. This request may not be retried.`);
-                else ApiClientBase_logger.error(`[${this.name}] "${requestName}" request failed:`, error);
-            }
-        }
-        const src_ApiClientBase = ApiClientBase;
+        const __rspack_default_export = LogSink;
     },
-    "./src/builders/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./src/lib/logger/logging.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            c: ()=>DEFAULT_PAGE_PROPERTIES,
-            e: ()=>builders_EventBuilder
-        });
-        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
-        const external_es_toolkit_namespaceObject = require("es-toolkit");
-        const mini_namespaceObject = require("zod/mini");
-        const UniversalEventBuilderArgs = mini_namespaceObject.object({
-            campaign: mini_namespaceObject.optional(optimization_api_schemas_.Campaign),
-            locale: mini_namespaceObject.optional(mini_namespaceObject.string()),
-            location: mini_namespaceObject.optional(optimization_api_schemas_.GeoLocation),
-            page: mini_namespaceObject.optional(optimization_api_schemas_.Page),
-            screen: mini_namespaceObject.optional(optimization_api_schemas_.Screen),
-            userAgent: mini_namespaceObject.optional(mini_namespaceObject.string())
-        });
-        const ComponentViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-            componentId: mini_namespaceObject.string(),
-            experienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
-            variantIndex: mini_namespaceObject.optional(mini_namespaceObject.number()),
-            sticky: mini_namespaceObject.optional(mini_namespaceObject.boolean())
+            A: ()=>logLevelSeverity
         });
-        const IdentifyBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-            traits: mini_namespaceObject.optional(optimization_api_schemas_.Traits),
-            userId: mini_namespaceObject.string()
-        });
-        const PageViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-            properties: mini_namespaceObject.optional(mini_namespaceObject.partial(optimization_api_schemas_.Page))
-        });
-        const ScreenViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-            name: mini_namespaceObject.string(),
-            properties: optimization_api_schemas_.Properties
-        });
-        const TrackBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-            event: mini_namespaceObject.string(),
-            properties: mini_namespaceObject.optional(mini_namespaceObject.prefault(optimization_api_schemas_.Properties, {}))
-        });
-        const DEFAULT_PAGE_PROPERTIES = {
-            path: '',
-            query: {},
-            referrer: '',
-            search: '',
-            title: '',
-            url: ''
+        const logLevelSeverity = {
+            fatal: 60,
+            error: 50,
+            warn: 40,
+            info: 30,
+            debug: 20,
+            log: 10
         };
-        class EventBuilder {
-            app;
-            channel;
-            library;
-            getLocale;
-            getPageProperties;
-            getUserAgent;
-            constructor(config){
-                const { app, channel, library, getLocale, getPageProperties, getUserAgent } = config;
-                this.app = app;
-                this.channel = channel;
-                this.library = library;
-                this.getLocale = getLocale ?? (()=>'en-US');
-                this.getPageProperties = getPageProperties ?? (()=>DEFAULT_PAGE_PROPERTIES);
-                this.getUserAgent = getUserAgent ?? (()=>void 0);
-            }
-            buildUniversalEventProperties({ campaign = {}, locale, location, page, screen, userAgent }) {
-                const timestamp = new Date().toISOString();
-                return {
-                    channel: this.channel,
-                    context: {
-                        app: this.app,
-                        campaign,
-                        gdpr: {
-                            isConsentGiven: true
-                        },
-                        library: this.library,
-                        locale: locale ?? this.getLocale() ?? 'en-US',
-                        location,
-                        page: page ?? this.getPageProperties(),
-                        screen,
-                        userAgent: userAgent ?? this.getUserAgent()
-                    },
-                    messageId: crypto.randomUUID(),
-                    originalTimestamp: timestamp,
-                    sentAt: timestamp,
-                    timestamp
-                };
-            }
-            buildComponentView(args) {
-                const { componentId, experienceId, variantIndex, ...universal } = ComponentViewBuilderArgs.parse(args);
-                return {
-                    ...this.buildUniversalEventProperties(universal),
-                    type: 'component',
-                    componentType: 'Entry',
-                    componentId,
-                    experienceId,
-                    variantIndex: variantIndex ?? 0
-                };
-            }
-            buildFlagView(args) {
-                return {
-                    ...this.buildComponentView(args),
-                    componentType: 'Variable'
-                };
-            }
-            buildIdentify(args) {
-                const { traits = {}, userId, ...universal } = IdentifyBuilderArgs.parse(args);
-                return {
-                    ...this.buildUniversalEventProperties(universal),
-                    type: 'identify',
-                    traits,
-                    userId
-                };
-            }
-            buildPageView(args = {}) {
-                const { properties = {}, ...universal } = PageViewBuilderArgs.parse(args);
-                const pageProperties = this.getPageProperties();
-                const merged = (0, external_es_toolkit_namespaceObject.merge)({
-                    ...pageProperties,
-                    title: pageProperties.title ?? DEFAULT_PAGE_PROPERTIES.title
-                }, properties);
-                const { context: { screen: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
-                const context = optimization_api_schemas_.PageEventContext.parse(universalContext);
-                return {
-                    ...universalProperties,
-                    context,
-                    type: 'page',
-                    properties: merged
-                };
-            }
-            buildScreenView(args) {
-                const { name, properties, ...universal } = ScreenViewBuilderArgs.parse(args);
-                const { context: { page: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
-                const context = optimization_api_schemas_.ScreenEventContext.parse(universalContext);
-                return {
-                    ...universalProperties,
-                    context,
-                    type: 'screen',
-                    name,
-                    properties
-                };
-            }
-            buildTrack(args) {
-                const { event, properties = {}, ...universal } = TrackBuilderArgs.parse(args);
-                return {
-                    ...this.buildUniversalEventProperties(universal),
-                    type: 'track',
-                    event,
-                    properties
-                };
-            }
-        }
-        const builders_EventBuilder = EventBuilder;
-    },
-    "./src/experience/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            n: ()=>EXPERIENCE_BASE_URL,
-            A: ()=>experience
-        });
-        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        var ApiClientBase = __webpack_require__("./src/ApiClientBase.ts");
-        const logger = (0, dist.zP)('ApiClient:Experience');
-        const EXPERIENCE_BASE_URL = 'https://experience.ninetailed.co/';
-        class ExperienceApiClient extends ApiClientBase.A {
-            baseUrl;
-            enabledFeatures;
-            ip;
-            locale;
-            plainText;
-            preflight;
-            constructor(config){
-                super('Experience', config);
-                const { baseUrl, enabledFeatures, ip, locale, plainText, preflight } = config;
-                this.baseUrl = baseUrl || EXPERIENCE_BASE_URL;
-                this.enabledFeatures = enabledFeatures;
-                this.ip = ip;
-                this.locale = locale;
-                this.plainText = plainText;
-                this.preflight = preflight;
-            }
-            async getProfile(id, options = {}) {
-                if (!id) throw new Error('Valid profile ID required.');
-                const requestName = 'Get Profile';
-                logger.info(`Sending "${requestName}" request`);
-                try {
-                    const response = await this.fetch(this.constructUrl(`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${id}`, options), {
-                        method: 'GET'
-                    });
-                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
-                    const data = {
-                        changes,
-                        personalizations: experiences,
-                        profile
-                    };
-                    logger.debug(`"${requestName}" request successfully completed`);
-                    return data;
-                } catch (error) {
-                    this.logRequestError(error, {
-                        requestName
-                    });
-                    throw error;
-                }
-            }
-            async makeProfileMutationRequest({ url, body, options }) {
-                return await this.fetch(this.constructUrl(url, options), {
-                    method: 'POST',
-                    headers: this.constructHeaders(options),
-                    body: JSON.stringify(body),
-                    keepalive: true
-                });
-            }
-            async createProfile({ events }, options = {}) {
-                const requestName = 'Create Profile';
-                logger.info(`Sending "${requestName}" request`);
-                const body = {
-                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
-                    options: this.constructBodyOptions(options)
-                };
-                logger.debug(`"${requestName}" request body:`, body);
-                try {
-                    const response = await this.makeProfileMutationRequest({
-                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,
-                        body,
-                        options
-                    });
-                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
-                    const data = {
-                        changes,
-                        personalizations: experiences,
-                        profile
-                    };
-                    logger.debug(`"${requestName}" request successfully completed`);
-                    return data;
-                } catch (error) {
-                    this.logRequestError(error, {
-                        requestName
-                    });
-                    throw error;
-                }
-            }
-            async updateProfile({ profileId, events }, options = {}) {
-                if (!profileId) throw new Error('Valid profile ID required.');
-                const requestName = 'Update Profile';
-                logger.info(`Sending "${requestName}" request`);
-                const body = {
-                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
-                    options: this.constructBodyOptions(options)
-                };
-                logger.debug(`"${requestName}" request body:`, body);
-                try {
-                    const response = await this.makeProfileMutationRequest({
-                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${profileId}`,
-                        body,
-                        options
-                    });
-                    const { data: { changes, experiences, profile } } = optimization_api_schemas_.ExperienceResponse.parse(await response.json());
-                    const data = {
-                        changes,
-                        personalizations: experiences,
-                        profile
-                    };
-                    logger.debug(`"${requestName}" request successfully completed`);
-                    return data;
-                } catch (error) {
-                    this.logRequestError(error, {
-                        requestName
-                    });
-                    throw error;
-                }
-            }
-            async upsertProfile({ profileId, events }, options) {
-                if (!profileId) return await this.createProfile({
-                    events
-                }, options);
-                return await this.updateProfile({
-                    profileId,
-                    events
-                }, options);
-            }
-            async upsertManyProfiles({ events }, options = {}) {
-                const requestName = 'Upsert Many Profiles';
-                logger.info(`Sending "${requestName}" request`);
-                const body = {
-                    events: optimization_api_schemas_.ExperienceEventArray.parse(events),
-                    options: this.constructBodyOptions(options)
-                };
-                logger.debug(`"${requestName}" request body:`, body);
-                try {
-                    const response = await this.makeProfileMutationRequest({
-                        url: `v2/organizations/${this.clientId}/environments/${this.environment}/events`,
-                        body,
-                        options: {
-                            plainText: false,
-                            ...options
-                        }
-                    });
-                    const { data: { profiles } } = optimization_api_schemas_.BatchExperienceResponse.parse(await response.json());
-                    logger.debug(`"${requestName}" request successfully completed`);
-                    return profiles;
-                } catch (error) {
-                    this.logRequestError(error, {
-                        requestName
-                    });
-                    throw error;
-                }
-            }
-            constructUrl(path, options) {
-                const url = new URL(path, this.baseUrl);
-                const locale = options.locale ?? this.locale;
-                const preflight = options.preflight ?? this.preflight;
-                if (locale) url.searchParams.set('locale', locale);
-                if (preflight) url.searchParams.set('type', 'preflight');
-                return url.toString();
-            }
-            constructHeaders({ ip = this.ip, plainText = this.plainText }) {
-                const headers = new Map();
-                if (ip) headers.set('X-Force-IP', ip);
-                if (plainText ?? this.plainText ?? true) headers.set('Content-Type', 'text/plain');
-                else headers.set('Content-Type', 'application/json');
-                return Object.fromEntries(headers);
-            }
-            constructBodyOptions = ({ enabledFeatures = this.enabledFeatures })=>{
-                const bodyOptions = {};
-                if (enabledFeatures && Array.isArray(enabledFeatures) && enabledFeatures.length > 0) bodyOptions.features = enabledFeatures;
-                else bodyOptions.features = [
-                    'ip-enrichment',
-                    'location'
-                ];
-                return bodyOptions;
-            };
-        }
-        const experience = ExperienceApiClient;
-    },
-    "./src/insights/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Q: ()=>INSIGHTS_BASE_URL,
-            A: ()=>insights
-        });
-        var optimization_api_schemas_ = __webpack_require__("@contentful/optimization-api-schemas");
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        var ApiClientBase = __webpack_require__("./src/ApiClientBase.ts");
-        const logger = (0, dist.zP)('ApiClient:Insights');
-        const INSIGHTS_BASE_URL = 'https://ingest.insights.ninetailed.co/';
-        class InsightsApiClient extends ApiClientBase.A {
-            baseUrl;
-            beaconHandler;
-            constructor(config){
-                super('Insights', config);
-                const { baseUrl, beaconHandler } = config;
-                this.baseUrl = baseUrl || INSIGHTS_BASE_URL;
-                this.beaconHandler = beaconHandler;
-            }
-            async sendBatchEvents(batches, options = {}) {
-                const { beaconHandler = this.beaconHandler } = options;
-                const url = new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`, this.baseUrl);
-                const body = optimization_api_schemas_.BatchInsightsEventArray.parse(batches);
-                if ('function' == typeof beaconHandler) {
-                    logger.debug('Queueing events via beaconHandler');
-                    const beaconSuccessfullyQueued = beaconHandler(url, body);
-                    if (beaconSuccessfullyQueued) return true;
-                    logger.warn('beaconHandler failed to queue events; events will be emitted immediately via fetch');
-                }
-                const requestName = 'Event Batches';
-                logger.info(`Sending "${requestName}" request`);
-                logger.debug(`"${requestName}" request body:`, body);
-                try {
-                    await this.fetch(url, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify(body),
-                        keepalive: true
-                    });
-                    logger.debug(`"${requestName}" request successfully completed`);
-                    return true;
-                } catch (error) {
-                    this.logRequestError(error, {
-                        requestName
-                    });
-                    return false;
-                }
-            }
-        }
-        const insights = InsightsApiClient;
-    },
-    "@contentful/optimization-api-schemas" (module) {
-        module.exports = require("@contentful/optimization-api-schemas");
     },
-    "../../lib/logger/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+    "./src/logger.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            zP: ()=>createScopedLogger
+            createScopedLogger: ()=>createScopedLogger
         });
-        const external_diary_namespaceObject = require("diary");
-        require("diary/utils");
-        class Logger {
+        class Logger_Logger {
             name = '@contentful/optimization';
             PREFIX_PARTS = [
                 'Ctfl',
                 'O10n'
             ];
             DELIMITER = ':';
-            diary;
             sinks = [];
-            constructor(){
-                this.diary = (0, external_diary_namespaceObject.diary)(this.name, this.onLogEvent.bind(this));
-                (0, external_diary_namespaceObject.enable)(this.name);
-            }
             assembleLocationPrefix(logLocation) {
                 return `[${[
                     ...this.PREFIX_PARTS,
@@ -578,22 +52,32 @@ var __webpack_modules__ = {
                 this.sinks = [];
             }
             debug(logLocation, message, ...args) {
-                this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('debug', logLocation, message, ...args);
             }
             info(logLocation, message, ...args) {
-                this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('info', logLocation, message, ...args);
             }
             log(logLocation, message, ...args) {
-                this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('log', logLocation, message, ...args);
             }
             warn(logLocation, message, ...args) {
-                this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('warn', logLocation, message, ...args);
             }
             error(logLocation, message, ...args) {
-                this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('error', logLocation, message, ...args);
             }
             fatal(logLocation, message, ...args) {
-                this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+                this.emit('fatal', logLocation, message, ...args);
+            }
+            emit(level, logLocation, message, ...args) {
+                this.onLogEvent({
+                    name: this.name,
+                    level,
+                    messages: [
+                        `${this.assembleLocationPrefix(logLocation)} ${String(message)}`,
+                        ...args
+                    ]
+                });
             }
             onLogEvent(event) {
                 this.sinks.forEach((sink)=>{
@@ -601,7 +85,7 @@ var __webpack_modules__ = {
                 });
             }
         }
-        const logger = new Logger();
+        const logger = new Logger_Logger();
         function createScopedLogger(location) {
             return {
                 debug: (message, ...args)=>{
@@ -624,6 +108,9 @@ var __webpack_modules__ = {
                 }
             };
         }
+        __webpack_require__("./src/lib/logger/logging.ts");
+        var LogSink = __webpack_require__("./src/lib/logger/LogSink.ts");
+        LogSink.A;
     }
 };
 var __webpack_module_cache__ = {};
@@ -636,15 +123,6 @@ function __webpack_require__(moduleId) {
     __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
     return module.exports;
 }
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -670,36 +148,430 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        ApiClient: ()=>_ApiClient__rspack_import_0.A,
-        DEFAULT_PAGE_PROPERTIES: ()=>_builders__rspack_import_3.c,
-        EXPERIENCE_BASE_URL: ()=>_experience__rspack_import_4.n,
-        EventBuilder: ()=>_builders__rspack_import_3.e,
-        INSIGHTS_BASE_URL: ()=>_insights__rspack_import_5.Q
+        createTimeoutFetchMethod: ()=>createTimeoutFetchMethod,
+        ExperienceApiClient: ()=>ExperienceApiClient,
+        createProtectedFetchMethod: ()=>createProtectedFetchMethod,
+        EXPERIENCE_BASE_URL: ()=>EXPERIENCE_BASE_URL,
+        ApiClient: ()=>ApiClient,
+        INSIGHTS_BASE_URL: ()=>INSIGHTS_BASE_URL,
+        createRetryFetchMethod: ()=>createRetryFetchMethod,
+        InsightsApiClient: ()=>InsightsApiClient
     });
-    var _ApiClient__rspack_import_0 = __webpack_require__("./src/ApiClient.ts");
-    var _contentful_optimization_api_schemas__rspack_import_1 = __webpack_require__("@contentful/optimization-api-schemas");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _contentful_optimization_api_schemas__rspack_import_1)if ([
-        "default",
-        "ApiClient"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_contentful_optimization_api_schemas__rspack_import_1[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    __webpack_require__("./src/ApiClientBase.ts");
-    var _builders__rspack_import_3 = __webpack_require__("./src/builders/index.ts");
-    var _experience__rspack_import_4 = __webpack_require__("./src/experience/index.ts");
-    var _insights__rspack_import_5 = __webpack_require__("./src/insights/index.ts");
+    const optimization_api_schemas_namespaceObject = require("@contentful/optimization-api-schemas");
+    var logger = __webpack_require__("./src/logger.ts");
+    const fetchInputToString = (input)=>{
+        if ('string' == typeof input) return input;
+        return input.url;
+    };
+    const MISSING_FETCH_METHOD_MESSAGE = 'No fetch implementation available. Provide a fetchMethod.';
+    function resolveFetchMethod(fetchMethod) {
+        if (fetchMethod) return fetchMethod;
+        if ('function' == typeof globalThis.fetch) return globalThis.fetch.bind(globalThis);
+        throw new Error(MISSING_FETCH_METHOD_MESSAGE);
+    }
+    const createRetryFetchMethod_logger = (0, logger.createScopedLogger)('ApiClient:Retry');
+    const DEFAULT_INTERVAL_TIMEOUT = 0;
+    const DEFAULT_RETRY_COUNT = 1;
+    const RETRY_RESPONSE_STATUS = 503;
+    const HTTP_ERROR_RESPONSE_STATUS = 500;
+    class HttpError extends Error {
+        status;
+        constructor(message, status = HTTP_ERROR_RESPONSE_STATUS){
+            super(message);
+            Object.setPrototypeOf(this, HttpError.prototype);
+            this.status = status;
+        }
+    }
+    function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod, init, url }) {
+        return async ()=>{
+            const urlLabel = fetchInputToString(url);
+            try {
+                const response = await fetchMethod(url, init);
+                if (response.status === RETRY_RESPONSE_STATUS) throw new HttpError(`${apiName} API request to "${urlLabel}" failed with status: "[${response.status}] ${response.statusText}".`, RETRY_RESPONSE_STATUS);
+                if (!response.ok) {
+                    const httpError = new Error(`Request to "${urlLabel}" failed with status: [${response.status}] ${response.statusText} - traceparent: ${response.headers.get('traceparent')}`);
+                    createRetryFetchMethod_logger.error('Request failed with non-OK status:', httpError);
+                    controller.abort();
+                    return;
+                }
+                createRetryFetchMethod_logger.debug(`Response from "${urlLabel}":`, response);
+                return response;
+            } catch (error) {
+                if (error instanceof HttpError && error.status === RETRY_RESPONSE_STATUS) throw error;
+                createRetryFetchMethod_logger.error(`Request to "${urlLabel}" failed:`, error);
+                controller.abort();
+            }
+        };
+    }
+    async function delayRetry(intervalTimeout) {
+        if (intervalTimeout <= 0) return;
+        const { promise, resolve } = Promise.withResolvers();
+        setTimeout(()=>{
+            resolve(void 0);
+        }, intervalTimeout);
+        await promise;
+    }
+    function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
+        const resolvedFetchMethod = resolveFetchMethod(fetchMethod);
+        return async (url, init)=>{
+            const controller = new AbortController();
+            const maxAttempts = retries + 1;
+            const attemptFetch = createRetryFetchCallback({
+                apiName,
+                controller,
+                fetchMethod: resolvedFetchMethod,
+                init,
+                url
+            });
+            for(let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber++)try {
+                const response = await attemptFetch();
+                if (response) return response;
+                break;
+            } catch (error) {
+                if (!(error instanceof HttpError) || error.status !== RETRY_RESPONSE_STATUS) throw error;
+                const retriesLeft = maxAttempts - attemptNumber;
+                onFailedAttempt?.({
+                    apiName,
+                    error,
+                    attemptNumber,
+                    retriesLeft
+                });
+                if (0 === retriesLeft) throw error;
+                await delayRetry(intervalTimeout);
+            }
+            throw new Error(`${apiName} API request to "${fetchInputToString(url)}" may not be retried.`);
+        };
+    }
+    const createTimeoutFetchMethod_logger = (0, logger.createScopedLogger)('ApiClient:Timeout');
+    const DEFAULT_REQUEST_TIMEOUT = 3000;
+    function isFetchAbortSignal(signal) {
+        return 'object' == typeof signal && null !== signal;
+    }
+    function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+        const resolvedFetchMethod = resolveFetchMethod(fetchMethod);
+        return async (url, init)=>{
+            const controller = new AbortController();
+            const id = setTimeout(()=>{
+                if ('function' == typeof onRequestTimeout) onRequestTimeout({
+                    apiName
+                });
+                else createTimeoutFetchMethod_logger.error(`Request to "${fetchInputToString(url)}" timed out`, new Error('Request timeout'));
+                controller.abort();
+            }, requestTimeout);
+            const { signal } = controller;
+            if (!isFetchAbortSignal(signal)) throw new Error('AbortController signal is not compatible with fetch.');
+            const requestInit = {
+                ...init,
+                signal
+            };
+            const response = await resolvedFetchMethod(url, requestInit);
+            clearTimeout(id);
+            return response;
+        };
+    }
+    const createProtectedFetchMethod_logger = (0, logger.createScopedLogger)('ApiClient:Fetch');
+    function createProtectedFetchMethod(options) {
+        try {
+            const timeoutFetchMethod = createTimeoutFetchMethod(options);
+            const retryFetchMethod = createRetryFetchMethod({
+                ...options,
+                fetchMethod: timeoutFetchMethod
+            });
+            return retryFetchMethod;
+        } catch (error) {
+            if (error instanceof Error) if ('AbortError' === error.name) createProtectedFetchMethod_logger.warn('Request aborted due to network issues. This request may not be retried.');
+            else createProtectedFetchMethod_logger.error('Request failed:', error);
+            throw error;
+        }
+    }
+    const Fetch = {
+        create: createProtectedFetchMethod
+    };
+    const fetch_Fetch = Fetch;
+    const fetch = fetch_Fetch;
+    const ApiClientBase_logger = (0, logger.createScopedLogger)('ApiClient');
+    const DEFAULT_ENVIRONMENT = 'main';
+    class ApiClientBase {
+        name;
+        clientId;
+        environment;
+        fetch;
+        constructor(name, { fetchOptions, clientId, environment }){
+            this.clientId = clientId;
+            this.environment = environment ?? DEFAULT_ENVIRONMENT;
+            this.name = name;
+            this.fetch = fetch.create({
+                ...fetchOptions ?? {},
+                apiName: name
+            });
+        }
+        logRequestError(error, { requestName }) {
+            if (error instanceof Error) if ('AbortError' === error.name) ApiClientBase_logger.warn(`[${this.name}] "${requestName}" request aborted due to network issues. This request may not be retried.`);
+            else ApiClientBase_logger.error(`[${this.name}] "${requestName}" request failed:`, error);
+        }
+    }
+    const src_ApiClientBase = ApiClientBase;
+    const ExperienceApiClient_logger = (0, logger.createScopedLogger)('ApiClient:Experience');
+    const EXPERIENCE_BASE_URL = 'https://experience.ninetailed.co/';
+    class ExperienceApiClient extends src_ApiClientBase {
+        baseUrl;
+        enabledFeatures;
+        ip;
+        locale;
+        plainText;
+        preflight;
+        constructor(config){
+            super('Experience', config);
+            const { baseUrl, enabledFeatures, ip, locale, plainText, preflight } = config;
+            this.baseUrl = baseUrl || EXPERIENCE_BASE_URL;
+            this.enabledFeatures = enabledFeatures;
+            this.ip = ip;
+            this.locale = locale;
+            this.plainText = plainText;
+            this.preflight = preflight;
+        }
+        setLocale(locale) {
+            this.locale = locale;
+        }
+        async getProfile(id, options = {}) {
+            if (!id) throw new Error('Valid profile ID required.');
+            const requestName = 'Get Profile';
+            ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+            try {
+                const response = await this.fetch(this.constructUrl(`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${id}`, options), {
+                    method: 'GET'
+                });
+                const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
+                const data = {
+                    changes,
+                    selectedOptimizations: experiences,
+                    profile
+                };
+                ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+                return data;
+            } catch (error) {
+                this.logRequestError(error, {
+                    requestName
+                });
+                throw error;
+            }
+        }
+        async makeProfileMutationRequest({ url, body, options }) {
+            return await this.fetch(this.constructUrl(url, options), {
+                method: 'POST',
+                headers: this.constructHeaders(options),
+                body: JSON.stringify(body),
+                keepalive: true
+            });
+        }
+        async createProfile({ events }, options = {}) {
+            const requestName = 'Create Profile';
+            ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+            const body = this.constructExperienceRequestBody(events, options);
+            ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+            try {
+                const response = await this.makeProfileMutationRequest({
+                    url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,
+                    body,
+                    options
+                });
+                const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
+                const data = {
+                    changes,
+                    selectedOptimizations: experiences,
+                    profile
+                };
+                ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+                return data;
+            } catch (error) {
+                this.logRequestError(error, {
+                    requestName
+                });
+                throw error;
+            }
+        }
+        async updateProfile({ profileId, events }, options = {}) {
+            if (!profileId) throw new Error('Valid profile ID required.');
+            const requestName = 'Update Profile';
+            ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+            const body = this.constructExperienceRequestBody(events, options);
+            ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+            try {
+                const response = await this.makeProfileMutationRequest({
+                    url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${profileId}`,
+                    body,
+                    options
+                });
+                const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
+                const data = {
+                    changes,
+                    selectedOptimizations: experiences,
+                    profile
+                };
+                ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+                return data;
+            } catch (error) {
+                this.logRequestError(error, {
+                    requestName
+                });
+                throw error;
+            }
+        }
+        async upsertProfile({ profileId, events }, options) {
+            if (!profileId) return await this.createProfile({
+                events
+            }, options);
+            return await this.updateProfile({
+                profileId,
+                events
+            }, options);
+        }
+        async upsertManyProfiles({ events }, options = {}) {
+            const requestName = 'Upsert Many Profiles';
+            ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+            const body = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.BatchExperienceRequestData, {
+                events,
+                options: this.constructBodyOptions(options)
+            });
+            ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+            try {
+                const response = await this.makeProfileMutationRequest({
+                    url: `v2/organizations/${this.clientId}/environments/${this.environment}/events`,
+                    body,
+                    options: {
+                        plainText: false,
+                        ...options
+                    }
+                });
+                const { data: { profiles } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.BatchExperienceResponse, await response.json());
+                ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+                return profiles;
+            } catch (error) {
+                this.logRequestError(error, {
+                    requestName
+                });
+                throw error;
+            }
+        }
+        constructUrl(path, options) {
+            const url = new URL(path, this.baseUrl);
+            const locale = options.locale ?? this.locale;
+            const preflight = options.preflight ?? this.preflight;
+            if (locale) url.searchParams.set('locale', locale);
+            if (preflight) url.searchParams.set('type', 'preflight');
+            return url.toString();
+        }
+        constructHeaders({ ip = this.ip, plainText = this.plainText }) {
+            const headers = new Map();
+            if (ip) headers.set('X-Force-IP', ip);
+            if (plainText ?? this.plainText ?? true) headers.set('Content-Type', 'text/plain');
+            else headers.set('Content-Type', 'application/json');
+            return Object.fromEntries(headers);
+        }
+        constructBodyOptions = ({ enabledFeatures = this.enabledFeatures })=>{
+            const bodyOptions = {};
+            if (enabledFeatures && Array.isArray(enabledFeatures) && enabledFeatures.length > 0) bodyOptions.features = enabledFeatures;
+            else bodyOptions.features = [
+                'ip-enrichment',
+                'location'
+            ];
+            return bodyOptions;
+        };
+        constructExperienceRequestBody(events, options) {
+            return optimization_api_schemas_namespaceObject.ExperienceRequestData.parse({
+                events: (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceEventArray, events),
+                options: this.constructBodyOptions(options)
+            });
+        }
+    }
+    const InsightsApiClient_logger = (0, logger.createScopedLogger)('ApiClient:Insights');
+    const BEACON_FALLBACK_MESSAGE = 'beacon failed; falling back to fetch';
+    const INSIGHTS_BASE_URL = 'https://ingest.insights.ninetailed.co/';
+    class InsightsApiClient extends src_ApiClientBase {
+        baseUrl;
+        constructor(config){
+            super('Insights', config);
+            const { baseUrl } = config;
+            this.baseUrl = baseUrl || INSIGHTS_BASE_URL;
+        }
+        async sendBatchEvents(batches, options = {}) {
+            const { beacon } = options;
+            const url = new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`, this.baseUrl);
+            const urlString = url.toString();
+            const body = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.BatchInsightsEventArray, batches);
+            const serializedBody = JSON.stringify(body);
+            if (beacon) {
+                InsightsApiClient_logger.debug('Queueing events via beacon');
+                try {
+                    const beaconSuccessfullyQueued = beacon(urlString, serializedBody);
+                    if (beaconSuccessfullyQueued) return true;
+                    InsightsApiClient_logger.warn(BEACON_FALLBACK_MESSAGE);
+                } catch (error) {
+                    InsightsApiClient_logger.warn(BEACON_FALLBACK_MESSAGE, error);
+                }
+            }
+            const requestName = 'Event Batches';
+            InsightsApiClient_logger.info(`Sending "${requestName}" request`);
+            InsightsApiClient_logger.debug(`"${requestName}" request body:`, body);
+            try {
+                await this.fetch(urlString, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: serializedBody,
+                    keepalive: !!beacon
+                });
+                InsightsApiClient_logger.debug(`"${requestName}" request successfully completed`);
+                return true;
+            } catch (error) {
+                this.logRequestError(error, {
+                    requestName
+                });
+                return false;
+            }
+        }
+    }
+    class ApiClient {
+        config;
+        experience;
+        insights;
+        constructor(config){
+            const { experience, insights, clientId, environment, fetchOptions } = config;
+            const apiConfig = {
+                clientId,
+                environment,
+                fetchOptions
+            };
+            this.config = apiConfig;
+            this.experience = new ExperienceApiClient({
+                ...apiConfig,
+                ...experience
+            });
+            this.insights = new InsightsApiClient({
+                ...apiConfig,
+                ...insights
+            });
+        }
+    }
 })();
 exports.ApiClient = __webpack_exports__.ApiClient;
-exports.DEFAULT_PAGE_PROPERTIES = __webpack_exports__.DEFAULT_PAGE_PROPERTIES;
 exports.EXPERIENCE_BASE_URL = __webpack_exports__.EXPERIENCE_BASE_URL;
-exports.EventBuilder = __webpack_exports__.EventBuilder;
+exports.ExperienceApiClient = __webpack_exports__.ExperienceApiClient;
 exports.INSIGHTS_BASE_URL = __webpack_exports__.INSIGHTS_BASE_URL;
+exports.InsightsApiClient = __webpack_exports__.InsightsApiClient;
+exports.createProtectedFetchMethod = __webpack_exports__.createProtectedFetchMethod;
+exports.createRetryFetchMethod = __webpack_exports__.createRetryFetchMethod;
+exports.createTimeoutFetchMethod = __webpack_exports__.createTimeoutFetchMethod;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ApiClient",
-    "DEFAULT_PAGE_PROPERTIES",
     "EXPERIENCE_BASE_URL",
-    "EventBuilder",
-    "INSIGHTS_BASE_URL"
+    "ExperienceApiClient",
+    "INSIGHTS_BASE_URL",
+    "InsightsApiClient",
+    "createProtectedFetchMethod",
+    "createRetryFetchMethod",
+    "createTimeoutFetchMethod"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true