# Logs

## List Gateway Logs

`client.AIGateway.Logs.List(ctx, gatewayID, params) (*V4PagePaginationArray[LogListResponse], error)`

**get** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs`

List Gateway Logs

### Parameters

- `gatewayID string`

  gateway id

- `params LogListParams`

  - `AccountID param.Field[string]`

    Path param

  - `Cached param.Field[bool]`

    Query param

  - `Direction param.Field[LogListParamsDirection]`

    Query param

    - `const LogListParamsDirectionAsc LogListParamsDirection = "asc"`

    - `const LogListParamsDirectionDesc LogListParamsDirection = "desc"`

  - `EndDate param.Field[Time]`

    Query param

  - `Feedback param.Field[LogListParamsFeedback]`

    Query param

    - `const LogListParamsFeedback0 LogListParamsFeedback = 0`

    - `const LogListParamsFeedback1 LogListParamsFeedback = 1`

  - `Filters param.Field[[]LogListParamsFilter]`

    Query param

    - `Key LogListParamsFiltersKey`

      - `const LogListParamsFiltersKeyID LogListParamsFiltersKey = "id"`

      - `const LogListParamsFiltersKeyCreatedAt LogListParamsFiltersKey = "created_at"`

      - `const LogListParamsFiltersKeyRequestContentType LogListParamsFiltersKey = "request_content_type"`

      - `const LogListParamsFiltersKeyResponseContentType LogListParamsFiltersKey = "response_content_type"`

      - `const LogListParamsFiltersKeyRequestType LogListParamsFiltersKey = "request_type"`

      - `const LogListParamsFiltersKeySuccess LogListParamsFiltersKey = "success"`

      - `const LogListParamsFiltersKeyCached LogListParamsFiltersKey = "cached"`

      - `const LogListParamsFiltersKeyProvider LogListParamsFiltersKey = "provider"`

      - `const LogListParamsFiltersKeyModel LogListParamsFiltersKey = "model"`

      - `const LogListParamsFiltersKeyModelType LogListParamsFiltersKey = "model_type"`

      - `const LogListParamsFiltersKeyCost LogListParamsFiltersKey = "cost"`

      - `const LogListParamsFiltersKeyTokens LogListParamsFiltersKey = "tokens"`

      - `const LogListParamsFiltersKeyTokensIn LogListParamsFiltersKey = "tokens_in"`

      - `const LogListParamsFiltersKeyTokensOut LogListParamsFiltersKey = "tokens_out"`

      - `const LogListParamsFiltersKeyDuration LogListParamsFiltersKey = "duration"`

      - `const LogListParamsFiltersKeyFeedback LogListParamsFiltersKey = "feedback"`

      - `const LogListParamsFiltersKeyEventID LogListParamsFiltersKey = "event_id"`

      - `const LogListParamsFiltersKeyMetadataKey LogListParamsFiltersKey = "metadata.key"`

      - `const LogListParamsFiltersKeyMetadataValue LogListParamsFiltersKey = "metadata.value"`

      - `const LogListParamsFiltersKeyAuthentication LogListParamsFiltersKey = "authentication"`

      - `const LogListParamsFiltersKeyWholesale LogListParamsFiltersKey = "wholesale"`

      - `const LogListParamsFiltersKeyCompatibilityMode LogListParamsFiltersKey = "compatibilityMode"`

      - `const LogListParamsFiltersKeyDLPAction LogListParamsFiltersKey = "dlp_action"`

    - `Operator LogListParamsFiltersOperator`

      - `const LogListParamsFiltersOperatorEq LogListParamsFiltersOperator = "eq"`

      - `const LogListParamsFiltersOperatorNeq LogListParamsFiltersOperator = "neq"`

      - `const LogListParamsFiltersOperatorContains LogListParamsFiltersOperator = "contains"`

      - `const LogListParamsFiltersOperatorLt LogListParamsFiltersOperator = "lt"`

      - `const LogListParamsFiltersOperatorGt LogListParamsFiltersOperator = "gt"`

    - `Value []LogListParamsFiltersValueUnion`

      - `UnionString`

      - `UnionFloat`

      - `UnionBool`

  - `MaxCost param.Field[float64]`

    Query param

  - `MaxDuration param.Field[float64]`

    Query param

  - `MaxTokensIn param.Field[float64]`

    Query param

  - `MaxTokensOut param.Field[float64]`

    Query param

  - `MaxTotalTokens param.Field[float64]`

    Query param

  - `MetaInfo param.Field[bool]`

    Query param

  - `MinCost param.Field[float64]`

    Query param

  - `MinDuration param.Field[float64]`

    Query param

  - `MinTokensIn param.Field[float64]`

    Query param

  - `MinTokensOut param.Field[float64]`

    Query param

  - `MinTotalTokens param.Field[float64]`

    Query param

  - `Model param.Field[string]`

    Query param

  - `ModelType param.Field[string]`

    Query param

  - `OrderBy param.Field[LogListParamsOrderBy]`

    Query param

    - `const LogListParamsOrderByCreatedAt LogListParamsOrderBy = "created_at"`

    - `const LogListParamsOrderByProvider LogListParamsOrderBy = "provider"`

    - `const LogListParamsOrderByModel LogListParamsOrderBy = "model"`

    - `const LogListParamsOrderByModelType LogListParamsOrderBy = "model_type"`

    - `const LogListParamsOrderBySuccess LogListParamsOrderBy = "success"`

    - `const LogListParamsOrderByCached LogListParamsOrderBy = "cached"`

  - `OrderByDirection param.Field[LogListParamsOrderByDirection]`

    Query param

    - `const LogListParamsOrderByDirectionAsc LogListParamsOrderByDirection = "asc"`

    - `const LogListParamsOrderByDirectionDesc LogListParamsOrderByDirection = "desc"`

  - `Page param.Field[int64]`

    Query param

  - `PerPage param.Field[int64]`

    Query param

  - `Provider param.Field[string]`

    Query param

  - `RequestContentType param.Field[string]`

    Query param

  - `ResponseContentType param.Field[string]`

    Query param

  - `Search param.Field[string]`

    Query param

  - `StartDate param.Field[Time]`

    Query param

  - `Success param.Field[bool]`

    Query param

### Returns

- `type LogListResponse struct{…}`

  - `ID string`

  - `Cached bool`

  - `CreatedAt Time`

  - `Duration int64`

  - `Model string`

  - `Path string`

  - `Provider string`

  - `Success bool`

  - `TokensIn int64`

  - `TokensOut int64`

  - `Cost float64`

  - `CustomCost bool`

  - `Metadata string`

  - `ModelType string`

  - `RequestContentType string`

  - `RequestType string`

  - `ResponseContentType string`

  - `StatusCode int64`

  - `Step int64`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  page, err := client.AIGateway.Logs.List(
    context.TODO(),
    "my-gateway",
    ai_gateway.LogListParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}
```

#### Response

```json
{
  "result": [
    {
      "id": "id",
      "cached": true,
      "created_at": "2019-12-27T18:11:19.117Z",
      "duration": 0,
      "model": "model",
      "path": "path",
      "provider": "provider",
      "success": true,
      "tokens_in": 0,
      "tokens_out": 0,
      "cost": 0,
      "custom_cost": true,
      "metadata": "metadata",
      "model_type": "model_type",
      "request_content_type": "request_content_type",
      "request_type": "request_type",
      "response_content_type": "response_content_type",
      "status_code": 0,
      "step": 0
    }
  ],
  "result_info": {
    "count": 0,
    "max_cost": 0,
    "max_duration": 0,
    "max_tokens_in": 0,
    "max_tokens_out": 0,
    "max_total_tokens": 0,
    "min_cost": 0,
    "min_duration": 0,
    "min_tokens_in": 0,
    "min_tokens_out": 0,
    "min_total_tokens": 0,
    "page": 0,
    "per_page": 0,
    "total_count": 0
  },
  "success": true
}
```

## Get Gateway Log Detail

`client.AIGateway.Logs.Get(ctx, gatewayID, id, query) (*LogGetResponse, error)`

**get** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}`

Retrieves detailed information for a specific AI Gateway log entry.

### Parameters

- `gatewayID string`

  gateway id

- `id string`

- `query LogGetParams`

  - `AccountID param.Field[string]`

### Returns

- `type LogGetResponse struct{…}`

  - `ID string`

  - `Cached bool`

  - `CreatedAt Time`

  - `Duration int64`

  - `Model string`

  - `Path string`

  - `Provider string`

  - `Success bool`

  - `TokensIn int64`

  - `TokensOut int64`

  - `Cost float64`

  - `CustomCost bool`

  - `Metadata string`

  - `ModelType string`

  - `RequestContentType string`

  - `RequestHead string`

  - `RequestHeadComplete bool`

  - `RequestSize int64`

  - `RequestType string`

  - `ResponseContentType string`

  - `ResponseHead string`

  - `ResponseHeadComplete bool`

  - `ResponseSize int64`

  - `StatusCode int64`

  - `Step int64`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  log, err := client.AIGateway.Logs.Get(
    context.TODO(),
    "my-gateway",
    "id",
    ai_gateway.LogGetParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", log.ID)
}
```

#### Response

```json
{
  "result": {
    "id": "id",
    "cached": true,
    "created_at": "2019-12-27T18:11:19.117Z",
    "duration": 0,
    "model": "model",
    "path": "path",
    "provider": "provider",
    "success": true,
    "tokens_in": 0,
    "tokens_out": 0,
    "cost": 0,
    "custom_cost": true,
    "metadata": "metadata",
    "model_type": "model_type",
    "request_content_type": "request_content_type",
    "request_head": "request_head",
    "request_head_complete": true,
    "request_size": 0,
    "request_type": "request_type",
    "response_content_type": "response_content_type",
    "response_head": "response_head",
    "response_head_complete": true,
    "response_size": 0,
    "status_code": 0,
    "step": 0
  },
  "success": true
}
```

## Patch Gateway Log

`client.AIGateway.Logs.Edit(ctx, gatewayID, id, params) (*LogEditResponse, error)`

**patch** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}`

Updates metadata for an AI Gateway log entry.

### Parameters

- `gatewayID string`

  gateway id

- `id string`

- `params LogEditParams`

  - `AccountID param.Field[string]`

    Path param

  - `Feedback param.Field[float64]`

    Body param

  - `Metadata param.Field[map[string, LogEditParamsMetadataUnion]]`

    Body param

    - `UnionString`

    - `UnionFloat`

    - `UnionBool`

  - `Score param.Field[float64]`

    Body param

### Returns

- `type LogEditResponse interface{…}`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.AIGateway.Logs.Edit(
    context.TODO(),
    "my-gateway",
    "id",
    ai_gateway.LogEditParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{
  "result": {},
  "success": true
}
```

## Delete Gateway Logs

`client.AIGateway.Logs.Delete(ctx, gatewayID, params) (*LogDeleteResponse, error)`

**delete** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs`

Delete Gateway Logs

### Parameters

- `gatewayID string`

  gateway id

- `params LogDeleteParams`

  - `AccountID param.Field[string]`

    Path param

  - `Filters param.Field[[]LogDeleteParamsFilter]`

    Query param

    - `Key LogDeleteParamsFiltersKey`

      - `const LogDeleteParamsFiltersKeyID LogDeleteParamsFiltersKey = "id"`

      - `const LogDeleteParamsFiltersKeyCreatedAt LogDeleteParamsFiltersKey = "created_at"`

      - `const LogDeleteParamsFiltersKeyRequestContentType LogDeleteParamsFiltersKey = "request_content_type"`

      - `const LogDeleteParamsFiltersKeyResponseContentType LogDeleteParamsFiltersKey = "response_content_type"`

      - `const LogDeleteParamsFiltersKeyRequestType LogDeleteParamsFiltersKey = "request_type"`

      - `const LogDeleteParamsFiltersKeySuccess LogDeleteParamsFiltersKey = "success"`

      - `const LogDeleteParamsFiltersKeyCached LogDeleteParamsFiltersKey = "cached"`

      - `const LogDeleteParamsFiltersKeyProvider LogDeleteParamsFiltersKey = "provider"`

      - `const LogDeleteParamsFiltersKeyModel LogDeleteParamsFiltersKey = "model"`

      - `const LogDeleteParamsFiltersKeyModelType LogDeleteParamsFiltersKey = "model_type"`

      - `const LogDeleteParamsFiltersKeyCost LogDeleteParamsFiltersKey = "cost"`

      - `const LogDeleteParamsFiltersKeyTokens LogDeleteParamsFiltersKey = "tokens"`

      - `const LogDeleteParamsFiltersKeyTokensIn LogDeleteParamsFiltersKey = "tokens_in"`

      - `const LogDeleteParamsFiltersKeyTokensOut LogDeleteParamsFiltersKey = "tokens_out"`

      - `const LogDeleteParamsFiltersKeyDuration LogDeleteParamsFiltersKey = "duration"`

      - `const LogDeleteParamsFiltersKeyFeedback LogDeleteParamsFiltersKey = "feedback"`

      - `const LogDeleteParamsFiltersKeyEventID LogDeleteParamsFiltersKey = "event_id"`

      - `const LogDeleteParamsFiltersKeyMetadataKey LogDeleteParamsFiltersKey = "metadata.key"`

      - `const LogDeleteParamsFiltersKeyMetadataValue LogDeleteParamsFiltersKey = "metadata.value"`

      - `const LogDeleteParamsFiltersKeyAuthentication LogDeleteParamsFiltersKey = "authentication"`

      - `const LogDeleteParamsFiltersKeyWholesale LogDeleteParamsFiltersKey = "wholesale"`

      - `const LogDeleteParamsFiltersKeyCompatibilityMode LogDeleteParamsFiltersKey = "compatibilityMode"`

      - `const LogDeleteParamsFiltersKeyDLPAction LogDeleteParamsFiltersKey = "dlp_action"`

    - `Operator LogDeleteParamsFiltersOperator`

      - `const LogDeleteParamsFiltersOperatorEq LogDeleteParamsFiltersOperator = "eq"`

      - `const LogDeleteParamsFiltersOperatorNeq LogDeleteParamsFiltersOperator = "neq"`

      - `const LogDeleteParamsFiltersOperatorContains LogDeleteParamsFiltersOperator = "contains"`

      - `const LogDeleteParamsFiltersOperatorLt LogDeleteParamsFiltersOperator = "lt"`

      - `const LogDeleteParamsFiltersOperatorGt LogDeleteParamsFiltersOperator = "gt"`

    - `Value []LogDeleteParamsFiltersValueUnion`

      - `UnionString`

      - `UnionFloat`

      - `UnionBool`

  - `Limit param.Field[int64]`

    Query param

  - `OrderBy param.Field[LogDeleteParamsOrderBy]`

    Query param

    - `const LogDeleteParamsOrderByCreatedAt LogDeleteParamsOrderBy = "created_at"`

    - `const LogDeleteParamsOrderByProvider LogDeleteParamsOrderBy = "provider"`

    - `const LogDeleteParamsOrderByModel LogDeleteParamsOrderBy = "model"`

    - `const LogDeleteParamsOrderByModelType LogDeleteParamsOrderBy = "model_type"`

    - `const LogDeleteParamsOrderBySuccess LogDeleteParamsOrderBy = "success"`

    - `const LogDeleteParamsOrderByCached LogDeleteParamsOrderBy = "cached"`

    - `const LogDeleteParamsOrderByCost LogDeleteParamsOrderBy = "cost"`

    - `const LogDeleteParamsOrderByTokensIn LogDeleteParamsOrderBy = "tokens_in"`

    - `const LogDeleteParamsOrderByTokensOut LogDeleteParamsOrderBy = "tokens_out"`

    - `const LogDeleteParamsOrderByDuration LogDeleteParamsOrderBy = "duration"`

    - `const LogDeleteParamsOrderByFeedback LogDeleteParamsOrderBy = "feedback"`

  - `OrderByDirection param.Field[LogDeleteParamsOrderByDirection]`

    Query param

    - `const LogDeleteParamsOrderByDirectionAsc LogDeleteParamsOrderByDirection = "asc"`

    - `const LogDeleteParamsOrderByDirectionDesc LogDeleteParamsOrderByDirection = "desc"`

### Returns

- `type LogDeleteResponse struct{…}`

  - `Success bool`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  log, err := client.AIGateway.Logs.Delete(
    context.TODO(),
    "my-gateway",
    ai_gateway.LogDeleteParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", log.Success)
}
```

#### Response

```json
{
  "success": true
}
```

## Get Gateway Log Request

`client.AIGateway.Logs.Request(ctx, gatewayID, id, query) (*LogRequestResponse, error)`

**get** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}/request`

Retrieves the original request payload for an AI Gateway log entry.

### Parameters

- `gatewayID string`

  gateway id

- `id string`

- `query LogRequestParams`

  - `AccountID param.Field[string]`

### Returns

- `type LogRequestResponse interface{…}`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.AIGateway.Logs.Request(
    context.TODO(),
    "my-gateway",
    "id",
    ai_gateway.LogRequestParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{}
```

## Get Gateway Log Response

`client.AIGateway.Logs.Response(ctx, gatewayID, id, query) (*LogResponseResponse, error)`

**get** `/accounts/{account_id}/ai-gateway/gateways/{gateway_id}/logs/{id}/response`

Retrieves the response payload for an AI Gateway log entry.

### Parameters

- `gatewayID string`

  gateway id

- `id string`

- `query LogResponseParams`

  - `AccountID param.Field[string]`

### Returns

- `type LogResponseResponse interface{…}`

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/cloudflare/cloudflare-go"
  "github.com/cloudflare/cloudflare-go/ai_gateway"
  "github.com/cloudflare/cloudflare-go/option"
)

func main() {
  client := cloudflare.NewClient(
    option.WithAPIToken("Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY"),
  )
  response, err := client.AIGateway.Logs.Response(
    context.TODO(),
    "my-gateway",
    "id",
    ai_gateway.LogResponseParams{
      AccountID: cloudflare.F("0d37909e38d3e99c29fa2cd343ac421a"),
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response)
}
```

#### Response

```json
{}
```