Atlas

Atlas Help Center

New Ticket

Identifying bugs (or, equally importantly, determining that bugs 

 a part of a customer's problems) is an important part of resolving many support tickets. 

Traditionally, information about new bugs is locked away in error logs that are visible only to the engineering team. Atlas opens up access to these logs to support agents to help in diagnosing root problems so that faster short-term resolutions can be achieved for customers (ie, workarounds) and so that the engineering team can get directly to the core of issues where bugs are the root cause.

Below, we'll outline the steps for sending errors logged in Sentry to Atlas.

To connect Atlas to Sentry, login to your Sentry account and go to Settings > Integrations. Search for Atlas. Select the Atlas icon and then click "Accept and Install."

Without any changes to your code, Atlas will automatically attempt to match Sentry errors to specific customer timelines based off of the user_id and email for the customer. If that user is only in a single session, it will also show up in that session replay.

You can improve your experience further by linking Sentry issues to Atlas sessions (instructions below). Doing this will:

assign Sentry errors to the correct session for customers with multiple simultaneous sessions

assign Sentry errors to the correct customer if their data hasn't been shared with Sentry

Pass the Atlas session id to Sentry as the 

 tag. Make sure to get the session id right before your Sentry request since it can be changed over time. For example:

Sentry.init({
   dsn: "",
   release: "my-project-name@2.3.12",
})

Sentry.addGlobalEventProcessor((event) => {
	const sessionId = window.Atlas?.recording?.getSessionId();
	event.tags = {
		...(event.tags || {}),
		["atlasSupport.sessionId"]: sessionId,
		["atlasSupport.sessionUrl"]: sessionId
			? "https://app.getatlas.io/sessions/" + sessionId : "",
	};
	return event;
});

This depends on the frameworks and tools used. 

Send the Atlas session id to the backend with every request via cookie or header

 tag containing atlas session id in your Sentry setup code.

# Setting up Sentry 
import sentry_sdk
sentry_sdk.init(SENTRY_URL)

# On each request pass the user details and atlas session id to sentry as a tag
atlas_session_id = request.headers.get("X-Atlas-Session-Id")
sentry_sdk.set_tag("atlasSupport.sessionId", atlas_session_id)
sentry_sdk.set_user({"email": user.email, "id": str(user.id)})

If a Sentry error does not contain session id, Atlas will try to guess it (this will only works for logged in users with single active session).

For help with your specific setup, reach out to us at 

Sentry Integration

To configure the internal dashboard, set the URL to the URL of an individual customer in your internal tool (e.g. 

https://www.myapp.com/admin/user?user_id={user_id}/

You can use variables in the URL by wrapping them in curly brackets (e.g., 

). You can use the following variables in your URL:

In order for your internal dashboard to be visible within Atlas, the page needs to allow embedding. To check for this, ensure that the HTTP response from your server:

(if you are using cookie based authentication)

If this is not set correctly, you’ll see an error that looks like:

' because an 
ancestor violates the following Content Security Policy 
directive: "frame-ancestors 'self'".

 header via your application server. Here are some examples for some of the most common servers:

Header set Content-Security-Policy "frame-ancestors 'atlas.so';"

add_header Content-Security-Policy "frame-ancestors 'atlas.so';";

 to the end to ensure that nginx sends the header regardless of response code.

You can use the HTTP Response Headers GUI in IIS Manager or add the following to your web.config:

<system.webServer>
  <httpProtocol>
    <customHeaders>
      <add name="Content-Security-Policy" value="frame-ancestors 'atlas.so';" />
    </customHeaders>
  </httpProtocol>
</system.webServer>

 header, you can extend it by adding value after semicolon (

 value, you can safely extend it by adding only 

If you are using cookie based authentication, then you will have to set the 

 attribute of the auth cookie to None so the cookie is accessible in Atlas UI.

from flask import Flask, make_response

app = Flask(__name__)

@app.route('/')
def hello_world():
    resp = make_response('Hello, World!');
    resp.set_cookie('same-site-cookie', 'foo', samesite=None);

Internal Dashboard

Sync your customer data from Segment to Atlas for enhanced support and analytics.

Segment integration with Atlas allows you to seamlessly forward customer events and properties from your Segment CDP to Atlas. This powerful connection enables you to leverage rich customer data for more personalized and efficient support.

Let's explore how to set up and use this integration.

*App configuration > Integrations > Segment

”*. You'll find two crucial pieces of information:

These will be used in the Segment configuration process.

To forward data from Segment to Atlas, you'll need to set up a custom function in Segment.

In your Segment dashboard, navigate to Functions. Create a new function

Copy and paste the provided Atlas script into the function:

// Token is available at https://app.getatlas.io/configuration/integrations/segment
const SEGMENT_TO_ATLAS_TOKEN = '';

const BASE_URL = 'https://api.atlas.so';
const API_VERSION = 'v1';

async function onIdentify(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/customers/upsert`;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }
    
    let firstName;
    let lastName;

    let fullName = event.traits.name;
    
    if (fullName) {
        firstName = fullName.split(' ')[0];
        lastName = fullName.substring(firstName.length).trim()
    } else {
        firstName = event.traits.firstName || event.traits.first_name
        lastName = event.traits.lastName || event.traits.last_name
    }

    const payload = {
        userId: event.userId,
        email: event.traits.email,
        firstName: firstName,
        lastName: lastName,
    };

    if (event.traits.phone) {
        payload['phoneNumber'] = event.traits.phone
    }

    if (event.traits.company) {
        const accountData = {
            name: event.traits.company.name,
            website: event.traits.company.domain,
            externalId: event.traits.company.id,
        };
        payload['account'] = accountData;
    }

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(payload)
        });

        if (response.status >= 300) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onTrack(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/events`;
    let response;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
        return;
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }

    const atlasEvent = {
        objectType: 'CUSTOMER',
        objectId: event.userId,
        name: 'Event Tracked',
        description: event.properties.title || '',
        payload: {
            ...event.context,
            ...event.properties
        }
    };

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(atlasEvent)
        });

        if (response.status >= 500 || response.status === 429) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onPage(event, settings) {
    const endpoint = `${BASE_URL}/${API_VERSION}/events`;
    let response;

    if (!event.userId) {
        throw new EventNotSupported('Mandatory parameters are missing');
        return;
    }

    if (!SEGMENT_TO_ATLAS_TOKEN) {
        console.log('Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing');
        return;
    }

    const atlasEvent = {
        objectType: 'CUSTOMER',
        objectId: event.userId,
        name: 'Page Viewed',
        description: event.properties.title || '',
        payload: {
            ...event.context,
            ...event.properties
        }
    };

    try {
        response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(atlasEvent)
        });

        if (response.status >= 500 || response.status === 429) {
            throw new RetryError(`Failed with ${response.status}`);
        }
    } catch (error) {
        throw new RetryError(error.message);
    }
}

async function onGroup(event, settings) {
  const endpoint = `${BASE_URL}/${API_VERSION}/accounts/upsert`;

  if (!event.userId) {
    throw new EventNotSupported("Mandatory parameters are missing");
  }

  if (!SEGMENT_TO_ATLAS_TOKEN) {
    console.log("Bad Configuration - SEGMENT_TO_ATLAS_TOKEN - missing");
    return;
  }

  const payload = {
    externalId: event.groupId,
    name: event.traits.name,
    email: event.traits.email,
  };

  try {
    response = await fetch(endpoint, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${SEGMENT_TO_ATLAS_TOKEN}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
    });
    if (response.status >= 300) {
      throw new RetryError(`Failed with ${response.status}`);
    }
  } catch (error) {
    throw new RetryError(error.message);
  }
  
}

Customize the script as needed to match your event structure.

The exact steps and script are detailed in our Segment configuration guide, which you can access from the integration page.

Once configured, Segment will forward events to Atlas as custom events. This means:

-All data sent from Segment will appear in Atlas under the custom events section

-You can use this data to trigger automations, enrich customer profiles, or provide context during support interactions

-The structure of these custom events will depend on how you've set up your Segment tracking and the customizations made to the forwarding script

Introduction and instructions for setting up connection with Segment