> ## Documentation Index
> Fetch the complete documentation index at: https://docs.statusstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Components

> Understanding components - the individual services monitored within your Stacks

## What is a Component?

A **Component** represents an individual service or system being monitored within a Stack. Components are the building blocks of your monitoring infrastructure - each Stack contains one or more components that together provide a complete picture of your service health.

## Types of Components

StatusStack supports three types of components, giving you flexibility in how you monitor your infrastructure:

<CardGroup cols={3}>
  <Card title="Third-Party Sources" icon="cloud">
    Monitor 5,200+ sources like AWS, Cloudflare, GitHub, and Stripe
  </Card>

  <Card title="Custom Monitors" icon="globe">
    Track your own websites and APIs with configurable health checks
  </Card>

  <Card title="Manual Components" icon="pen">
    Update component status manually via dashboard or API
  </Card>
</CardGroup>

***

## Third-Party Source Components

### What are Source Components?

Source components are services from our 5,200+ integrated sources. StatusStack automatically fetches status updates from these services and reflects them in your Stacks.

### Popular Sources

<AccordionGroup>
  <Accordion title="Cloud Infrastructure">
    * **AWS** - Amazon Web Services (EC2, S3, Lambda, RDS, etc.)
    * **Google Cloud** - Google Cloud Platform services
    * **Azure** - Microsoft Azure services
    * **DigitalOcean** - Cloud infrastructure and hosting
  </Accordion>

  <Accordion title="Content Delivery & DNS">
    * **Cloudflare** - CDN, DNS, and security services
    * **Fastly** - Edge cloud platform
    * **Akamai** - CDN and cloud services
  </Accordion>

  <Accordion title="Developer Tools">
    * **GitHub** - Code hosting and collaboration
    * **GitLab** - DevOps platform
    * **Bitbucket** - Git repository management
  </Accordion>

  <Accordion title="Payment Processing">
    * **Stripe** - Payment infrastructure
    * **PayPal** - Online payments
    * **Square** - Payment processing
  </Accordion>

  <Accordion title="Communication Services">
    * **SendGrid** - Email delivery
    * **Twilio** - SMS and voice
    * **Slack** - Team communication
    * **Discord** - Community platform
  </Accordion>

  <Accordion title="Monitoring & Security">
    * **Datadog** - Infrastructure monitoring
    * **New Relic** - Application performance
    * **Sentry** - Error tracking
  </Accordion>
</AccordionGroup>

### How Source Components Work

When you add a source component to your Stack:

1. **Selection**: Choose a service from our integrations (e.g., AWS)
2. **Component Selection**: Select which components to monitor (e.g., EC2, S3, Lambda)
3. **Automatic Updates**: StatusStack fetches status updates every 1-5 minutes
4. **Status Reflection**: Component status updates automatically in your Stack

```javascript theme={null}
// Example: AWS components in a Stack
{
  "stack": "Production Infrastructure",
  "components": [
    {
      "source": "AWS",
      "component": "EC2",
      "status": "operational",
      "last_updated": "2025-01-19T10:30:00Z"
    },
    {
      "source": "AWS",
      "component": "S3",
      "status": "operational",
      "last_updated": "2025-01-19T10:30:00Z"
    }
  ]
}
```

***

## Custom Website Monitors

### What are Custom Monitors?

Custom monitors let you track the health of your own websites, APIs, and services that aren't covered by our third-party integrations.

### Creating a Custom Monitor

<Steps>
  <Step title="Navigate to Monitors">
    Go to **Monitoring** → **Website Monitors** in the customer dashboard
  </Step>

  <Step title="Create Monitor">
    Click **"Create Monitor"** button
  </Step>

  <Step title="Configure Monitor">
    Set up your monitoring parameters:

    * **Name**: Descriptive name (e.g., "API Health Check")
    * **URL**: The endpoint to monitor
    * **Check Interval**: How often to check (30s, 1min, 5min)
    * **Timeout**: Maximum response time before failure
    * **Alert Threshold**: Consecutive failures before alerting
  </Step>

  <Step title="Add to Stack">
    Select which Stack(s) should include this monitor
  </Step>
</Steps>

### Monitor Configuration Options

**Basic Settings:**

* URL endpoint to monitor
* Check interval (30 seconds to 5 minutes)
* Request timeout (1-30 seconds)
* Alert threshold (1-10 consecutive failures)

**Advanced Settings:**

* Custom HTTP headers (for authenticated endpoints)
* Expected HTTP status codes (200, 201, 204, etc.)
* Expected response content matching
* SSL certificate expiry monitoring
* Follow redirects option

**Example Configuration:**

```javascript theme={null}
{
  "name": "Production API Health",
  "url": "https://api.yoursite.com/health",
  "interval": 60, // seconds
  "timeout": 10, // seconds
  "alert_threshold": 3, // failures
  "expected_status": 200,
  "headers": {
    "Authorization": "Bearer token",
    "X-API-Key": "your-key"
  },
  "ssl_check": true
}
```

### Monitor Status Detection

Custom monitors automatically determine status based on:

| Condition                                | Status      | Description                 |
| ---------------------------------------- | ----------- | --------------------------- |
| Response within timeout, expected status | Operational | Everything working normally |
| Slow response or unexpected status       | Degraded    | Performance issues detected |
| Timeout or connection failure            | Outage      | Service unreachable         |
| SSL certificate expires \< 7 days        | Degraded    | Certificate renewal needed  |

***

## Manual Components

### What are Manual Components?

Manual components are services you update yourself through the dashboard or API. Useful for:

* Internal services without public status pages
* Third-party services not in our integrations
* Custom infrastructure components
* Scheduled maintenance windows

### Creating Manual Components

<Steps>
  <Step title="Open Your Stack">
    Navigate to the Stack where you want to add a component
  </Step>

  <Step title="Add Component">
    Click **"Add Component"** → **"Manual Component"**
  </Step>

  <Step title="Configure Component">
    * **Name**: Component name (e.g., "Internal Database")
    * **Description**: Optional details
    * **Initial Status**: Set the starting status
  </Step>

  <Step title="Save">
    Click **Create** to add the component to your Stack
  </Step>
</Steps>

### Updating Manual Components

Update manual component status through the dashboard:

1. Open the Stack containing the component
2. Click on the component
3. Select new status and add optional message
4. Click **Update Status**

***

## Component Status Levels

All components use the same four status levels:

<CardGroup cols={2}>
  <Card title="🟢 Operational" icon="circle-check">
    Service is running normally with no issues detected
  </Card>

  <Card title="🟡 Degraded" icon="triangle-exclamation">
    Partial outage or performance issues affecting some users
  </Card>

  <Card title="🔴 Outage" icon="circle-xmark">
    Complete service failure - service is unavailable
  </Card>

  <Card title="🔵 Maintenance" icon="wrench">
    Scheduled maintenance window - temporary unavailability
  </Card>
</CardGroup>

### Status Hierarchy

When calculating Stack status, the **worst status wins**:

```javascript theme={null}
// Stack status calculation
if (any_component === 'outage') return 'CRITICAL'
if (any_component === 'degraded') return 'DEGRADED'
if (any_component === 'maintenance') return 'MAINTENANCE'
return 'OPERATIONAL'
```

**Example:**

```
Stack: Production Infrastructure
├─ AWS EC2: Operational ✓
├─ Cloudflare: Operational ✓
├─ Production API: Degraded ⚠️
└─ Payment Gateway: Operational ✓

Stack Overall Status: DEGRADED (because Production API is degraded)
```

***

## Component Monitoring & Updates

### Update Frequency

Different component types update at different intervals:

| Component Type      | Update Frequency | Method                     |
| ------------------- | ---------------- | -------------------------- |
| Third-Party Sources | 1-5 minutes      | Automatic from source      |
| Custom Monitors     | 30s - 5 minutes  | Configurable health checks |
| Manual Components   | On-demand        | Manual updates only        |

### Status History

StatusStack maintains a complete history of all component status changes:

* Timestamp of each status change
* Previous and new status
* Duration of each status
* Total uptime calculation
* Incident correlation

View component history by clicking on any component in your Stack.

### Component Details

Each component displays:

* **Current Status**: Real-time status indicator
* **Last Updated**: Timestamp of last status check
* **Uptime**: Percentage uptime (last 30 days)
* **Status History**: Timeline of status changes
* **Active Incidents**: Any ongoing incidents affecting this component

***

## Best Practices

### Naming Components

✅ **Good Component Names:**

* "Production API (us-east-1)"
* "Customer Database Primary"
* "CDN - North America"
* "Payment Processing Gateway"

❌ **Poor Component Names:**

* "Component 1"
* "Server"
* "API"
* "Production"

### Organizing Components

<Checklist>
  * [ ] Group related components in the same Stack
  * [ ] Use descriptive names that indicate purpose and location
  * [ ] Keep component count per Stack manageable (10-20)
  * [ ] Separate production from staging/dev environments
  * [ ] Configure appropriate check intervals for custom monitors
  * [ ] Set up notifications for critical components
</Checklist>

### Monitor Configuration

**For Custom Monitors:**

1. **Start Conservative**: Begin with 60-second intervals and adjust as needed
2. **Set Realistic Timeouts**: Account for normal response times + buffer
3. **Alert Threshold**: Use 3-5 consecutive failures to reduce false alarms
4. **SSL Monitoring**: Enable for all HTTPS endpoints
5. **Headers**: Include authentication headers for protected endpoints

***

## Component Notifications

Components can trigger notifications when their status changes. Configure notification rules to alert your team:

**By Stack:**

* Get notified when any component in a Stack changes status
* Perfect for production monitoring

**By Component:**

* Get notified only for specific critical components
* Useful for high-priority services

**By Status Level:**

* Alert only on outages (ignore degraded)
* Alert on all changes (operational → degraded → outage)

See the [Notifications documentation](/concepts/notifications) for configuration details.

***

## Component Limits

Current limits per organization tier:

| Plan         | Stacks    | Components per Stack | Custom Monitors | Total Components |
| ------------ | --------- | -------------------- | --------------- | ---------------- |
| Free         | 3         | 10                   | 5               | 30               |
| Starter      | 10        | 20                   | 25              | 200              |
| Professional | 50        | 50                   | 100             | 2,500            |
| Enterprise   | Unlimited | Unlimited            | Unlimited       | Unlimited        |

***

## Related Documentation

<CardGroup cols={2}>
  <Card title="Stacks" icon="layer-group" href="/concepts/stacks">
    Understanding Stack organization
  </Card>

  <Card title="Sources" icon="cloud" href="/concepts/sources">
    Browse all 5,200+ sources
  </Card>

  <Card title="Notifications" icon="bell" href="/concepts/notifications">
    Configure component-based alerts
  </Card>

  <Card title="Customer Dashboard" icon="gauge" href="/guides/customer-dashboard">
    Managing components in the dashboard
  </Card>
</CardGroup>

***

**Components are the individual building blocks of your monitoring infrastructure.** Mix third-party sources, custom monitors, and manual components to create comprehensive monitoring coverage for all your services.