init.js

/**
 * Copyright 2020-2025 New Relic, Inc. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
import { FEATURE_FLAGS } from '../../features/generic_events/constants'
import { isValidSelector } from '../dom/query-selector'
import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../session/constants'
import { warn } from '../util/console'
import { getNREUMInitializedAgent } from '../window/nreum'
import { getModeledObject } from './configurable'

/**
 * @typedef {import('./init-types').Init} Init
 */

const nrMask = '[data-nr-mask]'

/**
 * @returns {Init} the default configuration object
 */
const model = () => {
  const hiddenState = {
    feature_flags: [],
    experimental: {
      marks: false,
      measures: false,
      resources: false
    },
    mask_selector: '*',
    block_selector: '[data-nr-block]',
    mask_input_options: {
      color: false,
      date: false,
      'datetime-local': false,
      email: false,
      month: false,
      number: false,
      range: false,
      search: false,
      tel: false,
      text: false,
      time: false,
      url: false,
      week: false,
      // unify textarea and select element with text input
      textarea: false,
      select: false,
      password: true // This will be enforced to always be true in the setter
    }
  }
  return {
    ajax: { deny_list: undefined, block_internal: true, enabled: true, autoStart: true },
    api: {
      allow_registered_children: true,
      duplicate_registered_data: false
    },
    distributed_tracing: {
      enabled: undefined,
      exclude_newrelic_header: undefined,
      cors_use_newrelic_header: undefined,
      cors_use_tracecontext_headers: undefined,
      allowed_origins: undefined
    },
    get feature_flags () { return hiddenState.feature_flags },
    set feature_flags (val) { hiddenState.feature_flags = val },
    generic_events: { enabled: true, autoStart: true },
    harvest: { interval: 30 },
    jserrors: { enabled: true, autoStart: true },
    logging: { enabled: true, autoStart: true },
    metrics: { enabled: true, autoStart: true },
    obfuscate: undefined,
    page_action: { enabled: true },
    page_view_event: { enabled: true, autoStart: true },
    page_view_timing: { enabled: true, autoStart: true },
    performance: {
      get capture_marks () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.MARKS) || hiddenState.experimental.marks },
      set capture_marks (val) { hiddenState.experimental.marks = val },
      get capture_measures () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.MEASURES) || hiddenState.experimental.measures },
      set capture_measures (val) { hiddenState.experimental.measures = val },
      capture_detail: true,
      resources: {
        get enabled () { return hiddenState.feature_flags.includes(FEATURE_FLAGS.RESOURCES) || hiddenState.experimental.resources },
        set enabled (val) { hiddenState.experimental.resources = val },
        asset_types: [],
        first_party_domains: [],
        ignore_newrelic: true
      }
    },
    privacy: { cookies_enabled: true },
    proxy: {
      assets: undefined,
      beacon: undefined
    },
    session: {
      expiresMs: DEFAULT_EXPIRES_MS,
      inactiveMs: DEFAULT_INACTIVE_MS
    },
    session_replay: {
      autoStart: true,
      enabled: false,
      preload: false,
      sampling_rate: 10,
      error_sampling_rate: 100,
      collect_fonts: false,
      inline_images: false,
      fix_stylesheets: true,
      // recording config settings
      mask_all_inputs: true,
      // this has a getter/setter to facilitate validation of the selectors
      get mask_text_selector () { return hiddenState.mask_selector },
      set mask_text_selector (val) {
        if (isValidSelector(val)) hiddenState.mask_selector = `${val},${nrMask}`
        else if (val === '' || val === null) hiddenState.mask_selector = nrMask
        else warn(5, val)
      },
      // these properties only have getters because they are enforcable constants and should error if someone tries to override them
      get block_class () { return 'nr-block' },
      get ignore_class () { return 'nr-ignore' },
      get mask_text_class () { return 'nr-mask' },
      // props with a getter and setter are used to extend enforcable constants with customer input
      // we must preserve data-nr-block no matter what else the customer sets
      get block_selector () {
        return hiddenState.block_selector
      },
      set block_selector (val) {
        if (isValidSelector(val)) hiddenState.block_selector += `,${val}`
        else if (val !== '') warn(6, val)
      },
      // password: must always be present and true no matter what customer sets
      get mask_input_options () {
        return hiddenState.mask_input_options
      },
      set mask_input_options (val) {
        if (val && typeof val === 'object') hiddenState.mask_input_options = { ...val, password: true }
        else warn(7, val)
      }
    },
    session_trace: { enabled: true, autoStart: true },
    soft_navigations: { enabled: true, autoStart: true },
    spa: { enabled: true, autoStart: true },
    ssl: undefined,
    user_actions: { enabled: true, elementAttributes: ['id', 'className', 'tagName', 'type'] }
  }
}

const _cache = {}
const missingAgentIdError = 'All configuration objects require an agent identifier!'

export function getConfiguration (id) {
  if (!id) throw new Error(missingAgentIdError)
  if (!_cache[id]) throw new Error(`Configuration for ${id} was never set`)
  return _cache[id]
}

export function setConfiguration (id, obj) {
  if (!id) throw new Error(missingAgentIdError)
  _cache[id] = getModeledObject(obj, model())
  const agentInst = getNREUMInitializedAgent(id)
  if (agentInst) agentInst.init = _cache[id]
}

export function getConfigurationValue (id, path) {
  if (!id) throw new Error(missingAgentIdError)
  var val = getConfiguration(id)
  if (val) {
    var parts = path.split('.')
    for (var i = 0; i < parts.length - 1; i++) {
      val = val[parts[i]]
      if (typeof val !== 'object') return
    }
    val = val[parts[parts.length - 1]]
  }
  return val
}

// TO DO: a setConfigurationValue equivalent may be nice so individual
//  properties can be tuned instead of reseting the whole model per call to `setConfiguration(agentIdentifier, {})`