# SailPoint Coupa Connector Documentation

> Coupa Connector Documentation

# Documentation

# Connecting SailPoint and Coupa

To connect SailPoint with Coupa, perform the following tasks:

## Adding the Source in SailPoint

To connect to SailPoint, perform the following steps. Once the connection is made, you can configure it to meet your company's needs.

> [!IMPORTANT]
>
> By default, the provisioning feature is **disabled**, and the connector only supports read-only operations. To support provisioning operations, you must manually enable the feature in the source configuration.

**To configure a new source:**

1. Sign in to SailPoint.
2. Go to **Admin \> Connections \> Sources**.
3. Select **Create New**.
4. Search for the connector by entering the name in the search box, and then select **Actions**.
5. In the **Actions** dropdown list, select the setup method:

   - [**Express Setup**](<#configuring-a-source-using-express-setup>) - Quickly create a read-only connection to your target system by providing minimal configurations and authentication. On completion, aggregation is automatically started.

     > **Note**
     >
     > Express Setup supports Credential Providers. For information on supported credential providers and configuration, refer to [Credential Providers](<https://documentation.sailpoint.com/connectors/help/credential_providers.html>). For more information, contact your SailPoint Customer Service Manager.
   - [**Standard Setup**](<#configuring-a-source-using-standard-setup>) - Provide detailed basic configuration to create the source. Once the source is created, continue with source setup.

### Configuring a Source Using Express Setup

Express Setup minimizes the initial configuration process so you can quickly connect the application and immediately begin aggregating user account and entitlement data.

1. Review the directions and select **Start Express Setup**.
2. Review the pre-populated **Source Name**, **Source Owner**, and **Description**. To update, select **Edit**.

   > **Note**
   >
   > The source name must be unique. You can change these settings later in the source configuration.
3. Select **Virtual Appliance**. A virtual appliance is a Linux-based virtual machine that connects to your sources and apps using SailPoint APIs, connectors, and integrations. For more information about configuring and deploying virtual appliances, refer to [SailPoint Virtual Appliances](<https://documentation.sailpoint.com/saas/help/va/index.html>).
4. (Optional) If enabled for your organization, select the **Use a Credential Provider** checkbox to manage the source's authentication using a credential provider.

   > **Note**
   >
   > To add a Credential Provider in SailPoint, go to **Admin \> Connections \> Credential Providers**. For more information about credential providers, refer to [Credential Providers](<https://documentation.sailpoint.com/connectors/help/credential_providers.html>).
5. Configure the authentication to allow SailPoint to connect to the source. For more information, refer to the **Connection Settings** section.
6. Select **Finish**.

   After a successful test connection, the system creates your source and prompts you to run an aggregation.

   - If you want to aggregate now, select **Aggregate**.

     - To see the latest account aggregation history, go to **Account Management \> Account Aggregation**.
     - To see the list of aggregated source accounts, go to **Account Management \> Accounts**.
   - If you want to aggregate later, select **Exit**. This returns you to the **Sources** page. Your new source is listed, but contains no accounts or aggregation history yet.

### Configuring a Source Using Standard Setup

Use Standard Setup to configure the connector for full feature support.

1. In the **Source Name** field, enter a unique and descriptive name for your source. Source names cannot exceed 128 characters.
2. In the **Description** field, provide additional details about the source to help distinguish it from similar sources. This field allows a maximum of 2,000 characters.
3. In the **Source Owner** field, begin typing the name of an owner. Matches appear after you type two or more letters. For more information, refer to [Assigning a Source Owner](<https://documentation.sailpoint.com/saas/help/sources/index.html#assigning-a-source-owner>).
4. Under **Connection Type**, select **Direct Connection** or **Flat File**.

   - **Direct Connection** - A direct connection fetches data from the **Virtual Appliance Cluster** you choose as the application connector for the source. A direct connection configuration allows for real-time updates. For more information about configuring and deploying virtual appliances, refer to the [Virtual Appliance Reference Guide](<https://documentation.sailpoint.com/saas/help/va/index.html>).
   - **Flat File** - Select the flat file if no connector is available, or if another system restricts the connection. This option allows only reading and aggregating data as a generic/delimited application. Provisioning activity is unsupported, and additional configuration pages like connection settings and aggregation settings are unavailable.
5. If you selected **Direct Connection**, in **Virtual Appliance Cluster**, select the virtual appliance cluster that will be used as the application connector for the source.
6. (Optional) Select a governance group to grant its members [source](<https://documentation.sailpoint.com/saas/help/common/users/user_levels.html#source-sub-admin-user-level>) or [role](<https://documentation.sailpoint.com/saas/help/common/users/user_levels.html#role-sub-admin-user-level>) sub-admin level oversight of the source and its access. For more information, refer to [Creating and Managing Governance Groups](<https://documentation.sailpoint.com/saas/help/common/users/governance_groups.html>).
7. If this source represents a primary system containing your organization's personnel records, select the **Authoritative Source** checkbox. For more information, refer to [Creating Identity Profiles](<https://documentation.sailpoint.com/saas/help/setup/identity_profiles.html>).
8. Select **Continue**. The source is created, and you are navigated to the **Source Setup \> Base Configuration** page. Continue to configure your connected source there.

## Base Configuration

Provide the base configuration parameters. Information you entered in the Create New Source dialog is automatically entered into the fields in the Base Configuration page. You can edit this information if necessary.

1. Enter a unique name and description for the source.
2. In the **Source Owner** dropdown list, select the identity that owns this source.

   - To find a source owner, begin entering their name.
3. In the **Virtual Appliance Cluster** dropdown list, select the virtual appliance to use when communicating with your organization's systems. For more information, refer to [SailPoint Virtual Appliances](<https://documentation.sailpoint.com/saas/help/va/index.html>).
4. (Optional) If enabled for your organization, select the **Use a Credential Provider** checkbox to manage the source's authentication using a credential provider.

   > **Note**
   >
   > To add a credential provider, go to **Admin \> Connections \> Credential Providers**. For more information about credential providers, refer to [Credential Providers](<https://documentation.sailpoint.com/connectors/help/credential_providers.html>).
5. Configure the authentication to allow SailPoint to connect to the source. Refer to [Connection Settings](<#connection-settings>) for more information.
6. (Optional) In the **Governance Group for Source Management** dropdown list, select a governance group to associate with this source. For more information about governance groups, refer to [Associating Governance Groups with a Source](<https://documentation.sailpoint.com/saas/help/common/users/governance_groups.html#associating-a-governance-group-with-a-source>).
7. (Optional) Choose whether to enable or disable provisioning for the source. Provisioning is disabled by default.

   - **Enable Provisioning** - Set the toggle to **Enabled** to allow the source to create, update, and deactivate accounts in the connected source system.
   - **Disable Provisioning** - Set the toggle to **Disabled** to disable provisioning for the source. Disabling provisioning will prevent the creation, updating, or deactivating of accounts on this source.
8. Select **Save**.

## Connection Settings

Provide the information required to connect and interact with the source.

> [!NOTE]
>
> **Screenshot**
>
> [![Connection Settings](<https://documentation.sailpoint.com/connectors/coupa/va/help/img/conn_settings.png>)](<https://documentation.sailpoint.com/connectors/coupa/va/help/img/conn_settings.png>)

To configure your connection settings, complete the following:

1. Enter the **Base URL** for the Coupa system. For example, `https://{organization_name}.coupahost.com`
2. **Client Credentials** is the only supported **Grant Type**.
3. In **Token URL**, enter the URL required to request an access token for the configured client identifier. For example, `https://{organization_name}.coupahost.com/oauth2/token`
4. In **Client ID**, enter the OAuth 2.0 client identifier created in Coupa. For more information on generating the Client ID, refer to Registering OAuth 2.0 Client.
5. In **Client Secret**, enter the client secret for the configured client identifier. For more information on generating the Client Secret, refer to Registering OAuth 2.0 Client.
6. Enter the **Scopes** that the connector must include while requesting an access token for certain operations in the Coupa system. To add more than one scope, use a comma (,) as a separator.

   For example:

   ```text
   core.user.read, core.user.write, core.common.read
   ```

   For more information on the operations and their required scopes, refer to Required Permissions.
7. Select **Save**.

## Aggregation Settings

Provide the settings for your aggregation.

For more information about aggregation, refer to [Loading Account Data](<https://documentation.sailpoint.com/saas/help/accounts/loading_data.html>).

> [!NOTE]
>
> **Screenshot**
>
> [![Aggregation Settings](<https://documentation.sailpoint.com/connectors/coupa/va/help/img/aggregation_settings.jpg>)](<https://documentation.sailpoint.com/connectors/coupa/va/help/img/aggregation_settings.jpg>)

To configure your aggregation settings, complete the following:

1. Configure any of the options available:

   - Select the **Delta Aggregation** checkbox to aggregate accounts that have changed since the last aggregation process.
   - Enter a **Page Size** setting from 1-50. The Page Size is number of records to include in a single page when iterating over large data sets.
   - Enter an **Account Filter** to ensure the required accounts are aggregated. For example, to only aggregate standard users enter `type[blank]=true`. For more information and examples, refer to [Account Filters](<#account-filters>).
2. Select **Save**.

### Account Filters

The Coupa connector supports account aggregation filters to limit the user accounts aggregated. The default filter that the connector uses to aggregate only standard users is `type[blank]=true`. You can modify the filters per your requirements.

The following are examples of filters that can be added on the **Aggregation Settings** page in the **Account Filter** field:

- To only aggregate active users, enter the following:

  ```text
  status=active
  ```
- To aggregate users which use the SAML authentication method, enter the following:

  ```text
  authentication-method=saml
  ```
- To aggregate active standard users which use the SAML authentication method, enter the following:

  ```text
  type[blank]=true&status=active&authentication-method=saml
  ```

## Review and Test

Perform a test to confirm the connection to SailPoint.

1. Go to **Review and Test**.
2. Confirm that the entries in each field are correct.

   If you note any mistakes, return to the section and make corrections.
3. Select **Test Connection**.

## SailPoint Application Onboarding

SailPoint application onboarding enables you to easily onboard new applications and create sources following the successful onboarding of a discovery source. To use this feature, continue to **Discovered Applications** in the SailPoint user interface.

For more information, refer to [Application Onboarding](<https://documentation.sailpoint.com/saas/help/ai/app_onboarding/index.html>) in the SailPoint SaaS documentation.

# Integrating SailPoint with Coupa

> [!NOTE]
>
> **Integration**
>
> This is an integration and requires additional licensing or subscriptions to utilize it. For more information, contact your customer success manager.

The SailPoint Coupa connector provides governance capabilities for the users of the Coupa system. These capabilities include aggregation, user provisioning, and adding or removing entitlements at the account level. For more information, refer to [Supported Features](<#supported-features>).

> [!NOTE]
>
> To view the latest features, enhancements, and fixes for all SaaS connectors, refer to the [SaaS Release Notes](<https://community.sailpoint.com/release-notes/saas>) page.

## Supported Features

The SailPoint Coupa connector supports the following features:

#### Account Management

- Manage Coupa users
- Aggregate and refresh accounts
- Delta aggregation
- Aggregate and update custom attributes
- Account filters
- Create, update, enable, and disable accounts
- Add or remove entitlements
- Manage an account's user groups, content groups, account groups, and approval group memberships as entitlements (string type; no specific entitlement type)

#### Entitlement Management

- Manage Coupa roles
- Refresh and aggregate entitlements

For more information on features, refer to [Source Features](<https://community.sailpoint.com/knowledge/Identity-Security-Cloud-Source-Features>).

## Privilege Classification

SailPoint Privilege Classification helps organizations systematically categorize and manage the privilege levels of entitlements within their sources. By classifying entitlements as high, medium, or low, administrators can better understand the potential risk and impact associated with specific access rights. This allows automatic assignment of privilege levels based on system recommendations, custom-defined criteria, or a same level across all entitlements.

| Privilege Level | Description |
| --- | --- |
| High | Administrative level access to accounts |
| Medium | Administrative level access for a specific role or function |
| Low | Only basic access of data |

> [!NOTE]
>
> To manage Privilege Classification, users must have administrative roles such as Org Admin, Source Admin or Source Sub-Admin.

For more information, refer to [Managing Privilege Classification](<https://documentation.sailpoint.com/saas/help/loading_entitlements/privilege_classification.html>).

## Prerequisites

- You must have an OAuth 2.0 client registered with Coupa. For more information on registering the client, refer to [Registering OAuth 2.0 Client](<#registering-oauth-20-client>).
- Configure at least one virtual appliance cluster and successfully test the connection. For instructions, refer to the [Virtual Appliance Reference Guide](<https://documentation.sailpoint.com/saas/help/va/index.html>).

## Required Permissions

The following table lists the minimum requirements for scopes and their respective connector operations:

| Connector Operation | Scope |
| --- | --- |
| User - Read (Aggregation and Get Account) | core.user.read |
| User - Write (Create, Update, Enable, Disable, Entitlement Assignment, and Removal) | core.user.write |
| Roles - Read (Aggregation and Get Role) | core.common.read |

## Registering OAuth 2.0 Client

To connect to the Coupa source, you must have an OAuth 2.0 client registered on Coupa.

To register the OAuth 2.0 client and generate a Client ID and Client Secret, complete the following:

1. Sign in to Coupa as an Administrator or Integrations Administrator.
2. Go to **Setup \> Oauth2/OpenID Connect Clients**. In Setup, you can use the search box to search for `oauth` to find the proper entry.
3. Select **Create**.
4. For **Grant Type**, select **Client Credentials** and then enter a name for the **Client**, **Login**, **Contact Info**, and **Contact Email**.
5. Select the scopes you want to include in this API setup. Scopes are like a set of permissions set on the API key. For more information on the required scopes, refer to [Required Permissions](<#required-permissions>).
6. Select **Save**. Saving the client generates the Client ID and Client Secret values, which are needed to configure the Coupa connector.

# Machine Account Attributes

Machine account attributes are used in provisioning configurations for machine accounts.

After you have [created the required machine account subtypes](<https://documentation.sailpoint.com/saas/help/machine/account_configuration.html#creating-machine-account-subtypes>), you can use the machine account attributes to provision machine accounts in your SailPoint tenant.

Refer to [Machine Identity Security Overview](<https://documentation.sailpoint.com/saas/help/machine/index.html>) for more information.

## Machine Account Provisioning Attributes

| Field (name) | Type | Required | Notes |
| --- | --- | --- | --- |
| login | string | Yes | The user's login name. |
| firstname | string | Yes | The user's first name. |
| lastname | string | Yes | The user's last name. |
| email | string | Yes | The user's email address. |
| designation | string | No | The user's designation. |

# Provisioning

The Coupa connector supports provisioning, allowing you to create and manage accounts and entitlements in Coupa directly from SailPoint.

**Prerequisite:** Your system is configured for provisioning.

When SailPoint provisions new accounts to the source, it uses the attributes on the **Create Account** page as instructions or a template for what to include in the account. This page is also referred to as the *provisioning policy*.

When new access is granted on a source where a user does not already have an account, SailPoint automatically includes account creation in the provisioning. This applies whether provisioning is started from an access request or from an automated role or lifecycle state assignment.

For direct-connect sources, SailPoint automatically creates the account from this configuration. If the source is not configured as a direct-connect source, SailPoint creates and assigns a provisioning task to the source owner and includes the values for the source owner to use in manually creating the account.

> [!IMPORTANT]
>
> This section describes the default **Create Account** configuration. SailPoint recommends that you work with Services to define a provisioning configuration specific to your company's needs. Be sure to verify large changes to the provisioning policy before implementation. Failure to do so might cause provisioning to fail.

For more information on the provisioning attributes, refer to [Provisioning Attributes](<#provisioning-attributes>).

## Provisioning Attributes

The following lists the provisioning attributes:

| Attribute Name | Description |
| --- | --- |
| login | The user's login name |
| firstname | The user's first name |
| middlename | The user's middle name |
| lastname | The user's last name |
| sso-identifier | The user's single sign-on ID (SSO ID) |
| authentication-method | Authentication method for user. For example, `coupa_credentials` or `saml` |
| email | The user's email address |
| generate-password-and-notify | Specifies whether to generate a password and notify the user to create a new one. This is only required when you are trying to create a Coupa user with the authentication method set as Coupa Credentials. |
| active | The user's active status |

# Schema Reference

The application schema is used to configure the objects returned from a connector.

> [!NOTE]
>
> - The **Account Schema** tab is used to define the attributes for each object type in the application being configured. The schema attributes can be defined as **Entitlement** or **Multi-Valued**. Refer to [Managing Source Account Schemas](<https://documentation.sailpoint.com/saas/help/accounts/schema.html>) for more information.
> - The schema attributes that are not present by [default](<#default-account-schema>) must be defined as strings if not specified.

The Coupa connector uses the following default correlation and object configurations.

## Default Account Schema

Each source supports a variety of details, or attributes, about each user who has an account, such as their name, email address, manager name, and location.

The set of account attributes each source stores and how they're organized is known as the account's *schema*. To best represent your data, you can configure sources to use an account schema matching the one you use in the external connector. Refer to [Managing Source Account Schemas](<https://documentation.sailpoint.com/saas/help/accounts/schema.html>) for more information.

### Default Account ID

SailPoint requires that certain attributes remain in your configuration. These attributes are referred to as *account IDs*.

> [!CAUTION]
>
> Changing the attribute marked as the account ID after aggregating accounts can result in duplicate accounts being created. To avoid this, either reset the accounts on this source before editing the account ID attribute or edit the account ID attribute before aggregating accounts.
>
> To resolve issues caused by changing account IDs, reconfigure them to their default values.

The following table lists the default account IDs for this connector:

| Account ID | Schema Object Type |
| --- | --- |
| id | Account |
| Id | Role |

### Default Account Attributes

The Coupa connector supports the following default account schema attributes and customer configurable attributes. The attributes must be defined as strings if not specified.

| Attribute Name | Description |
| --- | --- |
| id | Coupa unique user identifier. This is an Account ID which must not be changed. |
| login | The user's login name |
| firstname | The user's first name |
| lastname | The user's last name |
| middlename | The user's middle name |
| fullname | The user's full name |
| email | The user's email address |
| active | The user's active status |
| default-currency | The user's default currency code |
| employee-payment-channel | Expense payment channel for user. For example, `ERP` or `CoupaPay` |
| authentication-method | Authentication method for user. For example, `coupa_credentials` or `saml` |
| employee-number | The user's employee number |
| manager | The user's manager's name |
| purchasing-user | Specifies whether or not the user has a Purchasing license. |
| expense-user | Specifies whether or not the user has an Expense license. |
| sourcing-user | Specifies whether or not the user has a Sourcing license. |
| inventory-user | Specifies whether or not the user has an Inventory license. |
| invoicing-user | Specifies whether or not the user has an Invoicing license. This attribute is not included in the default account schema. You must manually add it to the schema if required. The connector always aggregates Invoicing-licensed users. The `invoicing-user` attribute only indicates whether the users have the Invoicing license. |
| contracts-user | Specifies whether or not the user has a Contracts license. |
| sso-identifier | The user's single sign-on ID (SSO ID) |
| roles | List of roles attached to the user |
| user-groups | List of user groups attached to the user |
| content-groups | List of content groups attached to the user |
| approval-groups | List of approval groups attached to the user |
| account-groups | List of account groups attached to the user |
| licenses | List of licenses attached to the user |

> [!NOTE]
>
> The following licenses are handled as entitlements under the **licenses** attribute: purchasing-user, expense-user, sourcing-user, inventory-user, invoicing-user, contracts-user, analytics-user, aic-user, ccw-user, risk-assess-user, supply-chain-user, treasury-user, travel-user, spend-guard-user, clm-advanced-user, category-planner-user, category-strategy-user, msp-user.
>
> If you have any custom license in use, configure it with the multi-valued list `customLicenseAttributes` attribute through a `PATCH API` in the application attribute. For example:
>
> ```json
> [
>   {
>     "op": "add",
>     "path": "/connectorAttributes/customLicenseAttributes",
>     "value": ["<custom license attribute 1>", "<custom license attribute 2>"]
>   }
> ]
> ```

### Account Schema Extension for Standard and Custom Attributes

Configure the connector to include custom attributes from the source in account aggregation processes. To include additional custom attributes in the account aggregation processes, add the attribute name to the account schema exactly as it is configured in the source schema.

If you want to extend the default account schema and provisioning policy to manage other standard or custom attributes, you can use either of the following methods. When you add attributes to a default schema, whether they are standard or custom, you are extending the schema.

During account aggregation, the connector uses the default filter, `return_object=shallow`. If the aggregated data for custom attributes is incomplete using the default filter, then you need to add the `return_object=full` filter to the **Account Filter** field on the [Aggregation Settings](<https://documentation.sailpoint.com/connectors/coupa/va/help/connecting.html#aggregation-settings>) page.

For example, if the existing account filter is `type[blank]=true` and you need to fetch more data through the API as a result of extending the schema, then you can update the filter to `type[blank]=true&return_object=full`.

On the downside, adding the `return_object=full` filter degrades aggregation performance, since fetching full objects results in an increase in API response time and size. SailPoint recommends that you add schema attributes that require the full account filter only if they are critical for deployment.

#### Method 1

Add attributes returned by the `/users` API. The following are examples for standard, complex, and custom attributes:

- **Standard Attributes** - To add a mobile phone number for a user, define the `phone-mobile` attribute in the account schema and the provisioning policy.
- **Complex Attributes** - You can use "dot walking" to navigate to the field you want to include in the account schema or the provisioning policy. The following are examples for using dot walking:

  - To add the name of a country of residence, define `country-of-residence.name` as the field name in the schema and provisioning policy.
  - To show the country code for country of residence, define `country-of-residence.code` as the field name in the schema and provisioning policy.
- **Custom Attributes** - If it is a complex attribute, use dot walking to navigate to the field you are interested in using. Use the following format:

  ```text
  custom-fields.<field_name>
  ```

  For example, if `designation` is a custom attribute in your Coupa tenant, then add the `custom-fields.designation` attribute to the account schema and account provisioning policy.

> [!NOTE]
>
> For more information on the Coupa `/users` API, refer to [Users API](<https://success.coupa.com/Integrate/Technical_Documentation/API/Resources/Reference/users>).

#### Method 2

Add a JSONPath (JPath) based mapping to the connector in the `customUserObjectMapping` field.

For example, if you want to add definitions for the `roles` (standard attribute) and `designation` (custom attribute) attributes, you can map them to your connector using the following:

```xml
<entry key="customUserObjectMapping">
    <value>
        <Map>
            <entry key="roles" value="roles[*].name"/>
            <entry key="designation" value="custom-fields.designation"/>
        </Map>
    </value>
</entry>
```

Then you can update the account schema and account provisioning policy with just the name of the attribute. For example, `roles` or `designation` as a string type entry.

> [!NOTE]
>
> For more information on SailPoint's REST APIs, refer to [Best Practices: REST API Authentication](<https://developer.sailpoint.com/docs/api/authentication/>) and [REST API - Update Source (Partial)](<https://developer.sailpoint.com/docs/api/update-source-v-1/>) in the SailPoint Developer Community.

### Default Role Attributes

The Coupa connector supports roles. The following attributes must be configured on the managed system and in the SailPoint source schema to manage roles.

| Attribute Name | Description |
| --- | --- |
| id | Coupa unique user identifier. This is an Account ID which must not be changed. |
| name | The name of the role |
| description | The description of the role |
| omnipotent | Specifies whether it is an administrative role or not |
| created-at | Denotes the time stamp for when the role is created |
| updated-at | Denotes the time stamp for when the role is updated |
| system-role | Indicates if the role is a system role |

# Enable Connector Logging

This topic provides the steps needed to enable logging on SailPoint using REST APIs.

> [!NOTE]
>
> This topic only applies to VA-based integrations.

> [!NOTE]
>
> The examples provided might not match your configuration. Use the logging levels and logging classes reference at the bottom of the topic to configure your API responses to match your connector.

This process is broken up into four steps:

1. Identify the Virtual Appliance (VA) cluster on which you want to enable logging.
2. Get the logging configuration for the existing VA cluster.
3. Update the VA cluster to enable logging levels.
4. Observe logging changes to the logging levels.

### Identify the Virtual Appliance Cluster

Select the VA on which you need to enable logging using REST API. If you already know the VA application's `id`, proceed to [Get the Logging Configuration](<#get-the-logging-configuration>).

1. Make the following call to the REST API to return a list of available VA clusters:

   GET /v3/managed-clusters

   The REST API returns a response that looks similar to the following:

   ```json
   [
       {
           "id": "2c9180866166b5b0016167c32ef31a66",
           "name": "Development Cluster",
           "description": "Development Cluster",
           "clientType": "CCG",
           "ccgVersion": "373_535_70.2.0",
           "pinnedConfig": true,
           "logConfiguration": null
       },
       {
           "id": "2c9180846a93ce60016ab29f039944de",
           "name": "Cloud Cluster",
           "description": "Cloud Cluster",
           "clientType": "CCG",
           "ccgVersion": "373_535_70.2.0",
           "pinnedConfig": true,
           "logConfiguration": {
               "clientId": null,
               "durationMinutes": 60,
               "expiration": "2020-12-15T19:13:36.079Z",
               "rootLevel": "DEBUG",
               "logLevels": {
                   "sailpoint.connector.ADLDAPConnector": "DEBUG"
               }
           }
       }
   ]
   ```

   > **Note**
   >
   > The previous example code shows two VA clusters. One VA cluster has a log configuration and the other does not (refer to the `logConfiguration` value in each returned VA cluster). This is because one of the clusters already has logging enabled. This is just an example configuration, and your environment may not have logging enabled on a cluster.
2. Identify the VA cluster that you want to enable logging on by its name or description and record its `id` attribute.

### Get the Logging Configuration

Get your selected VA's cluster logging configuration and identify the values you need to update.

1. Make the following call to the REST API to return the VA cluster's logging configuration. Replace `{id}` with the VA cluster's `id` attribute value recorded earlier.

   GET /v3/managed-clusters/{id}/log-config

   - If the VA doesn't have a logging configuration currently set, it returns `204 No Content` as a response.
   - If the VA has an existing logging configuration, it returns something similar to the following:

     ```json
     {
         "clientId": null,
         "durationMinutes": 60,
         "expiration": "2020-12-15T19:13:36.079Z",
         "rootLevel": "DEBUG",
         "logLevels": {
             "sailpoint.connector.ADLDAPConnector": "DEBUG"
         }
     }
     ```

     You'll need to configure the following information in the response:

     - `durationMinutes` is the number of minutes logging should remain enabled.
     - `rootLevel` is the default level for all logs. For more information, refer to [Logging Levels](<#logging-levels>).
     - `logLevels` is a map object with logging classes as keys and logging levels as values.

       - For keys, refer to [Logging Classes](<#logging-classes>) for commonly used logging classes.
       - For a list of available values, refer to [Logging Levels](<#logging-levels>).

### Update Logging Configuration

Update the VA cluster configuration returned by the REST API to update the logging settings as needed.

1. Make the following call to the REST API to update the VA cluster's logging configuration. Replace `{id}` with the VA cluster's `id` attribute value recorded earlier.

   PUT /v3/managed-clusters/{id}/log-config
2. Submit your configuration changes to the REST API in a JSON body.

   - If the VA cluster did not already have a logging configuration and you received a `204 No Content` response, you can create a new one.
   - If the VA returned a configuration, you can edit it to include the changes.

   The JSON body should be as follows:

   ```json
   {
       "durationMinutes": 60,
       "rootLevel": "DEBUG",
       "logLevels": {
           "sailpoint.connector.ADLDAPConnector": "DEBUG"
       }
   }
   ```

   Consider the following as you edit the JSON:

   - `durationMinutes` is the number of minutes logging should remain enabled.
   - `rootLevel` is the default level for all logs. For more information, refer to [Logging Levels](<#logging-levels>).
   - `logLevels` is a map object with logging classes as keys and logging levels as values.

     - For keys, refer to [Logging Classes](<#logging-classes>) for commonly used logging classes.
     - For a list of available values, refer to [Logging Levels](<#logging-levels>).

   If the update was successful, the REST API should return a response similar to the following:

   ```json
   {
       "clientId": null,
       "durationMinutes": 60,
       "expiration": "2020-12-15T19:13:36.079Z",
       "rootLevel": "DEBUG",
       "logLevels": {
           "sailpoint.connector.ADLDAPConnector": "DEBUG"
       }
   }
   ```

### Observe Logging Changes

Approximately five minutes after you update the configuration, the VA cluster starts generating log files you can review. You can view the log files in **ccg.log**.

### References

The tables in this reference section list information that can be helpful when creating the JSON body you'll use to configure the VA cluster's configuration file.

#### Logging Levels

| Logging Level | Description |
| --- | --- |
| ERROR | Designates error events that might still allow the connector to continue. |
| WARN | Designates potentially harmful situations. |
| INFO | Designates information messages that highlight process at a coarse-grain level. |
| DEBUG | Very verbose. Fine grain logging levels used for development and debugging. |
| TRACE | Most verbose. Finer grain logging levels than debugging. |

#### Logging Classes

| Connector | Logging Class |
| --- | --- |
| Active Directory | sailpoint.connector.ADLDAPConnector sailpoint.connector.LDAPConnector |
| AIX | openconnector.connector.unix.AIXConnector openconnector.connector.unix.UnixConnector |
| Amazon Web Services | logger.aws.name=openconnector.connector.aws logger.aws.level=trace logger.aws.additivity = false logger.aws.appenderRef.rolling.ref = STDOUT |
| Atlassian Suite Cloud | sailpoint.connector.OpenConnectorAdapter openconnector.connector.atlassian.AtlassianConnector |
| Atlassian Data Center | sailpoint.connector.OpenConnectorAdapter openconnector.connector.atlassian.AtlassianDataCenterConnector |
| Microsoft Entra ID | sailpoint.connector.AzureADConnector |
| Box | openconnector.connector.BoxNetConnector sailpoint.connector.OpenConnectorAdapter |
| Cerner | openconnector.connector.CernerConnector sailpoint.connector.OpenConnectorAdapter |
| Delimited File | logger.DelimitedFileConnector.name = sailpoint.connector.DelimitedFileConnector logger.DelimitedFileConnector.level = debug logger.DelimitedFileConnector.additivity = false logger.DelimitedFileConnector.appenderRef.rolling.ref = STDOUT |
| Dropbox | openconnector.connector.DropBoxConnector sailpoint.connector.OpenConnectorAdapter |
| Epic | openconnector.connector.EPICConnector sailpoint.connector.OpenConnectorAdapter |
| GE Centricity | openconnector.connector.GECentricity sailpoint.connector.OpenConnectorAdapter |
| Google Apps / G Suite | openconnector.connector.GoogleAppsDirect sailpoint.connector.OpenConnectorAdapter |
| IBM i | openconnector.connector.IBMiConnector |
| Lotus Domino | sailpoint.connector.LotusDomino |
| JDBC | sailpoint.connector.JDBCConnector |
| Sun One LDAP | sailpoint.connector.LDAPConnector |
| Linux | openconnector.connector.unix.LinuxConnector sailpoint.connector.OpenConnectorAdapter sailpoint.connector.UnixConnector |
| Microsoft Office365 | sailpoint.connector.Office365Connector |
| Microsoft SQL Server | sailpoint.connector.mssql.serviceimpl.MSSQLServerConnectorV2 |
| Okta | logger.openconnector.name = openconnector.connector.okta.OktaConnector logger.openconnector.level = debug logger.openconnector.additivity = false logger.openconnector.appenderRef.rolling.ref = STDOUT |
| Oracle Database | sailpoint.connector.OracleDBConnector sailpoint.connector.JDBCConnector |
| Oracle E-Business | sailpoint.connector.OracleEBSConnector sailpoint.connector.JDBCConnector |
| Oracle Fusion HCM | openconnector.connector.oraclefusionhcm.OracleFusionHCMConnector sailpoint.connector.OpenConnectorAdapter |
| Oracle HCM Cloud | sailpoint.connector.oraclehcmcloud.OracleHCMCloudConnector |
| Oracle HRMS | sailpoint.connector.OracleAppsHRMSConnector sailpoint.connector.JDBCConnector |
| Oracle Netsuite | openconnector.connector.netsuite.NetsuiteConnector |
| PeopleSoft ERP | openconnector.connector.PeopleSoftConnector sailpoint.connector.OpenConnectorAdapter |
| PeopleSoft HRMS | sailpoint.connector.PeopleSoftHRMSConnector |
| RemedyForce | sailpoint.connector.ForceConnector |
| RSA Authentication Manager | openconnector.connector.RSAConnector openconnector.connector.rsa.RSAHTTPClient sailpoint.connector.OpenConnectorAdapter |
| Salesforce | sailpoint.connector.ForceConnector |
| SAP Concur | openconnector.connector.sapconcur.SAPConcurConnector |
| SAP - Direct | sailpoint.connector.SAPConnector sailpoint.connector.SAPInternalConnector |
| SAP GRC | logger.SAPGRCConnector.name = sailpoint.connector.sapgrc logger.SAPGRCConnector.level = debug logger.SAPGRCConnector.additivity = false logger.SAPGRCConnector.appenderRef.rolling.ref = STDOUT |
| SAP HR/HCM | sailpoint.connector.SAPHRInternalConnector |
| SCIM 1.1 | openconnector.connector.SCIMConnector sailpoint.connector.OpenConnectorAdapter |
| SCIM 2.0 | openconnector.connector.scim2.SCIM2Connector sailpoint.connector.OpenConnectorAdapter |
| ServiceNow | openconnector.connector.servicenow.ServiceNowConnector openconnector.connector.servicenow.ServiceNowRestClient sailpoint.connector.OpenConnectorAdapter |
| ServiceNow Service Desk Integration | openconnector.connector.servicedesk.ServiceNowServiceDeskConnector sailpoint.connector.OpenConnectorAdapter |
| Siebel | openconnector.connector.SiebelConnector sailpoint.connector.OpenConnectorAdapter |
| Snowflake | openconnector.connector.snowflake.SnowflakeConnector sailpoint.connector.OpenConnectorAdapter |
| Solaris | openconnector.connector.unix.SolarisConnector openconnector.connector.unix.UnixConnector sailpoint.connector.OpenConnectorAdapter |
| SuccessFactors | sailpoint.connector.SuccessFactorsConnector |
| Sybase | sailpoint.connector.SybaseDirectConnector sailpoint.connector.JDBCConnector |
| Webex | openconnector.connector.Webex sailpoint.connector.OpenConnectorAdapter |
| Workday | openconnector.connector.WorkDay sailpoint.connector.OpenConnectorAdapter |
| Workday Accounts | openconnector.connector.workdayaccounts openconnector.connector.workdayaccounts.WorkdayAccountsConnector sailpoint.connector.OpenConnectorAdapter |
| Web Services | sailpoint.connector.WebServices |
| XML | openconnector.connector.XMLConnector sailpoint.connector.OpenConnectorAdapter |
| Yammer | openconnector.connector.YammerConnector sailpoint.connector.OpenConnectorAdapter |
| Zoom | openconnector.connector.zoom.ZoomConnector sailpoint.connector.OpenConnectorAdapter |

# Troubleshooting

If you encounter any of the following issues or errors, SailPoint recommends that you follow the guidance provided below to resolve the error before contacting SailPoint Support.

For issues or errors that are not addressed in this connector guide, refer to the following resources for troubleshooting information:

- [SailPoint Identity Services Documentation](<https://documentation.sailpoint.com/saas/help/index.html>)
- [SailPoint Support Knowledge Base](<https://support.sailpoint.com/csm?id=kb_view2&amp;kb_id=05ff44289f011200550bf7b6077fcfa3>)
- [SailPoint Developer Community](<https://developer.sailpoint.com/>)

## Country Code Attribute Is Not Fetched During Aggregation

**Resolution**: To resolve this issue, update the following entries in the Application configuration:

1. Remove the `invoicing_user` attribute from the account schema:

   ```xml
   <AttributeDefinition name="invoicing_user" type="boolean"/>
   ```
2. Update `userObjectMapping`:

   ```xml
   <entry key="country-code" value="default-address.country.code"/>
   ```
3. Add `country-code` to the account schema:

   ```xml
   <AttributeDefinition name="country-code" type="string"/>
   ```
4. Update `accountFilter`:

   ```xml
   <entry key="accountFilter" value="type[blank]=true&return_object=full"/>
   ```

## Any Attributes Added to "customUserObjectMapping" with a Value Containing the Keyword "amount" Are Not Provisioned Correctly

For example:

```json
"requisition-approval-limit": {
"amount": 999999999,
"currency": {
"code": "USD"
}
```

**Resolution**: Add the attributes that contain the "amount" value to the `attrsToExcludeCurrencyCode` entry to skip them during provisioning. The following example shows the entry to skip the requisition-approval-limit and expense-approval-limit that contain values with the amount keyword (as shown in the first example).

Add the entry using the REST API:

```text
PATCH https://sailpoint.api.identitynow.com/v3/sources/:id
```

In the body of the PATCH, use the form-data as follows:

- **Key**: `attrsToExcludeCurrencyCode`
- **Value**: `requisition-approval-limit,expense-approval-limit`