create_browser_monitor

Instructions

Implementation Reference

• src/tools/synthetics.ts:32-64 (schema)

  Tool schema definition for 'create_browser_monitor' — defines name, description, inputSchema (name, url, frequency, locations, optional target_account_id)

  getCreateMonitorTool(): Tool {
    return {
      name: 'create_browser_monitor',
      description: 'Create a new browser-based Synthetics monitor',
      inputSchema: {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            description: 'Name of the monitor',
          },
          url: {
            type: 'string',
            description: 'URL to monitor',
          },
          frequency: {
            type: 'number',
            enum: [1, 5, 10, 15, 30, 60],
            description: 'Check frequency in minutes',
          },
          locations: {
            type: 'array',
            items: { type: 'string' },
            description: 'Location codes for monitoring',
          },
          target_account_id: {
            type: 'string',
            description: 'Optional New Relic account ID',
          },
        },
        required: ['name', 'url', 'frequency', 'locations'],
      },
    };

• src/tools/synthetics.ts:115-171 (handler)

  Core handler method 'createBrowserMonitor' in SyntheticsTool class — executes the NerdGraph mutation 'syntheticsCreateSimpleBrowserMonitor' to create a browser monitor with name, url, period, locations, and status ENABLED. Handles error response.

  async createBrowserMonitor(input: {
    target_account_id?: string;
    name: string;
    url: string;
    frequency: number;
    locations: string[];
  }): Promise<Record<string, unknown> | null> {
    const accountId = input.target_account_id;
    if (!accountId) {
      throw new Error('Account ID must be provided');
    }
  
    const mutation = `
      mutation {
        syntheticsCreateSimpleBrowserMonitor(
          accountId: ${accountId}
          monitor: {
            name: "${input.name}"
            uri: "${input.url}"
            period: ${this.frequencyToPeriod(input.frequency)}
            status: ENABLED
            locations: {
              public: ${JSON.stringify(input.locations)}
            }
          }
        ) {
          monitor {
            id
            name
            uri
            period
            status
          }
          errors {
            type
            description
          }
        }
      }
    `;
  
    const response = await this.client.executeNerdGraphQuery<{
      syntheticsCreateSimpleBrowserMonitor?: {
        monitor?: Record<string, unknown>;
        errors?: Array<{ description?: string }>;
      };
    }>(mutation);
    const result = response.data?.syntheticsCreateSimpleBrowserMonitor;
  
    if (Array.isArray(result?.errors) && result!.errors!.length > 0) {
      throw new Error(
        `Failed to create monitor: ${result!.errors![0]?.description || 'Unknown error'}`
      );
    }
  
    return (result?.monitor as Record<string, unknown>) || null;
  }

• src/server.ts:57-105 (registration)

  Tool registration in the server — line 78 registers syntheticsTool.getCreateMonitorTool() into the tools Map, making it available for discovery.

  private registerTools(): void {
    const nrqlTool = new NrqlTool(this.client);
    const apmTool = new ApmTool(this.client);
    const entityTool = new EntityTool(this.client);
    const alertTool = new AlertTool(this.client);
    const syntheticsTool = new SyntheticsTool(this.client);
    const nerdGraphTool = new NerdGraphTool(this.client);
    const restDeployments = new RestDeploymentsTool();
    const restApm = new RestApmTool();
    const restMetrics = new RestMetricsTool();
  
    // Register all tools
    const tools = [
      nrqlTool.getToolDefinition(),
      apmTool.getListApplicationsTool(),
      entityTool.getSearchTool(),
      entityTool.getDetailsTool(),
      alertTool.getPoliciesTool(),
      alertTool.getIncidentsTool(),
      alertTool.getAcknowledgeTool(),
      syntheticsTool.getListMonitorsTool(),
      syntheticsTool.getCreateMonitorTool(),
      nerdGraphTool.getQueryTool(),
      // REST v2 tools
      restDeployments.getCreateTool(),
      restDeployments.getListTool(),
      restDeployments.getDeleteTool(),
      restApm.getListApplicationsTool(),
      restMetrics.getListMetricNamesTool(),
      restMetrics.getMetricDataTool(),
      restMetrics.getListApplicationHostsTool(),
      {
        name: 'get_account_details',
        description: 'Get New Relic account details',
        inputSchema: {
          type: 'object' as const,
          properties: {
            target_account_id: {
              type: 'string' as const,
              description: 'Optional account ID to get details for',
            },
          },
        },
      },
    ];
  
    tools.forEach((tool) => {
      this.tools.set(tool.name, tool);
    });

• src/server.ts:258-307 (registration)

  Tool execution dispatch and input validation in executeTool() — when name='create_browser_monitor', validates name/url/frequency/locations, then calls SyntheticsTool.createBrowserMonitor()

      case 'create_browser_monitor': {
        const { name, url, frequency, locations } = args as Record<string, unknown>;
        if (typeof name !== 'string' || name.trim() === '') {
          throw new Error('create_browser_monitor: "name" (non-empty string) is required');
        }
        if (typeof url !== 'string' || url.trim() === '') {
          throw new Error('create_browser_monitor: "url" (non-empty string) is required');
        }
        if (typeof frequency !== 'number' || !Number.isFinite(frequency) || frequency <= 0) {
          throw new Error('create_browser_monitor: "frequency" (positive number) is required');
        }
        if (
          !Array.isArray(locations) ||
          (locations as unknown[]).some((l) => typeof l !== 'string')
        ) {
          throw new Error('create_browser_monitor: "locations" must be an array of strings');
        }
        return await new SyntheticsTool(this.client).createBrowserMonitor({
          name,
          url,
          frequency,
          locations: locations as string[],
          target_account_id: accountId,
        });
      }
      case 'run_nerdgraph_query':
        return await new NerdGraphTool(this.client).execute(args);
      default: {
        const tool = this.tools.get(name);
        if (!tool) {
          throw new Error(`Tool ${name} not found`);
        }
        throw new Error(`Tool handler for ${name} not implemented`);
      }
    }
  }
  
  private requiresAccountId(toolName: string): boolean {
    const accountRequiredTools = [
      'run_nrql_query',
      'list_apm_applications',
      'search_entities',
      'get_account_details',
      'list_alert_policies',
      'list_open_incidents',
      'list_synthetics_monitors',
      'create_browser_monitor',
    ];
    return accountRequiredTools.includes(toolName);
  }

• src/tools/synthetics.ts:173-183 (helper)

  Helper method 'frequencyToPeriod' used by createBrowserMonitor — maps numeric frequency (1,5,10,15,30,60) to NerdGraph period strings (EVERY_MINUTE, EVERY_5_MINUTES, etc.)

  private frequencyToPeriod(frequency: number): string {
    const periodMap: { [key: number]: string } = {
      1: 'EVERY_MINUTE',
      5: 'EVERY_5_MINUTES',
      10: 'EVERY_10_MINUTES',
      15: 'EVERY_15_MINUTES',
      30: 'EVERY_30_MINUTES',
      60: 'EVERY_HOUR',
    };
    return periodMap[frequency] || 'EVERY_5_MINUTES';
  }