---
title: "Conas tuairisciú earráide a bhainisti"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/howto/error-reporting/
canonical: https://djangodocs.dev/ga/6.1/howto/error-reporting/
---
# Conas tuairisciú earráide a bhainisti

Nuair a bhíonn suíomh poiblí á reáchtáil agat ba chóir duit an socrú: setting: DEBUG a mhúchadh i gcónaí. Cuirfidh sé sin go rithfidh do fhreastalaí i bhfad níos gasta, agus cuirfidh sé cosc ar úsáideoirí mailíseacha sonraí d'iarratas a fheiceáil ar féidir leis na leathanaigh earráide a nochtadh.

Mar sin féin, ciallaíonn rith le:setting: DEBUG socraithe go `False` ní fheicfidh tú earráidí a ghineann do shuíomh riamh - feicfidh gach duine do leathanaigh earráide poiblí ina ionad sin. Ní mór duit súil a choinneáil ar earráidí a tharlaíonn i suíomhanna imscartha, ionas gur féidir Django a chumrú chun tuarascálacha a chruthú le sonraí faoi na hearráidí sin.

## Tuarascálacha ríomh

### Earráidí freastalaí

Nuair: Socrú: `False` ná DEBUG, ríomhphostálfaidh Django na húsáideoirí atá liostaithe sa socrú: Setting: ADMINS aon uair a ardaíonn do chód eisceacht neamh-láimhseáilte agus bíonn earráid inmheánach freastalaí mar thoradh air (go docht, le haghaidh aon fhreagra le cód stádais HTTP 500 nó níos mó). Tugann sé seo fógra láithreach do na riarthóirí faoi aon earráidí. Gheobhaidh an: SETTING: ADMINS cur síos ar an earráid, rianú iomlán Python, agus sonraí faoin iarratas HTTP a bhí ina chúis leis an earráid.

> **Note**
>
> Chun ríomhphost a sheoladh, éilíonn Django roinnt socruithe a insíonn dó conas ceangal le do fhreastalaí ríomhphoist. Ar a laghad, beidh ort :socrú: EMAIL\_HOST a shonrú agus b'fhéidir : socrú: EMAIL\_HOST\_USER agus : socrú: EMAIL\_HOST\_PASSWORD a shonrú, cé go bhféadfadh socruithe eile a bheith ag teastáil freisin ag brath ar chumraíocht do fhreastalaí ríomhphoist. Téigh i gcomhairle le [doiciméadú socruithe Django](/ga/6.1/ref/settings/) le haghaidh liosta iomlán de shocruithe a bhaineann le ríomhphost.

By default, Django will send email from `root@localhost`. However, some mail
providers reject all email from this address. To use a different sender
address, modify the [`SERVER_EMAIL`](/ga/6.1/ref/settings/#std-setting-SERVER_EMAIL) setting.

Chun an t-iompar seo a ghníomhachtú, cuir seoltaí ríomhphoist na bhfaighteoirí sa socrú: socrú: ADMINS.

> **See also**
>
> Seoltar ríomhphoist earráide freastalaí leis an gcreat logála, ionas gur féidir leat an t-iompar seo a shaincheapadh trí :doc: do chumraíocht logála a shaincheapadh \</topics/logáil\>.

### 404 earráidí

Is féidir Django a chumrú freisin chun earráidí ríomhphoist faoi naisc briste (404 earráidí “nár aimsíodh leathanach”). Seolann Django ríomhphoist faoi earráidí 404 nuair:

- [`DEBUG`](/ga/6.1/ref/settings/#std-setting-DEBUG) is `False`;
- Cuimsíonn do shuíomh: Socrú: MIDDLEWARE: aicme: django.middleware.common.BrokenLinkemailsMiddleware.

Má chomhlíontar na coinníollacha sin, cuirfidh Django ríomhphost chuig na húsáideoirí atá liostaithe sa socrú: SETTING: MANAGERS aon uair a ardaíonn do chód 404 agus tá tagairtí ag an iarraidh. Ní chuireann sé isteach ar ríomhphost a dhéanamh do 404s nach bhfuil tagairteoir acu - de ghnáth is daoine iad sin ag clóscríobh URLanna briste nó róbótaí gréasáin briste. Déanann sé neamhaird freisin ar 404s nuair a bhíonn an tagairteoir cothrom leis an URL iarrtha, ós rud é go dtagann an t-iompar seo ó róbótaí gréasáin briste freisin.

> **Note**
>
> [`BrokenLinkEmailsMiddleware`](/ga/6.1/ref/middleware/#django.middleware.common.BrokenLinkEmailsMiddleware) must appear
> before other middleware that intercepts 404 errors, such as
> [`LocaleMiddleware`](/ga/6.1/ref/middleware/#django.middleware.locale.LocaleMiddleware) or
> [`FlatpageFallbackMiddleware`](/ga/6.1/ref/contrib/flatpages/#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware).
> Put it toward the top of your [`MIDDLEWARE`](/ga/6.1/ref/settings/#std-setting-MIDDLEWARE) setting.

Is féidir leat a rá le Django stop a chur le tuairisciú 404s áirithe tríd an socrú: setting: IGNORABLE\_404\_URLS a mhodhnú. Ba chóir go mbeadh sé ina liosta de rudaí léirithe rialta tiomsaithe. Mar shampla:

```
import re

IGNORABLE_404_URLS = [
    re.compile(r"\.(php|cgi)$"),
    re.compile(r"^/phpmyadmin/"),
]
```

Sa sampla seo, tuairiscífear 404 chuig aon URL a chríochnaíonn le `.php` nó `.cgi` *ní*. Ní bheidh aon URL ag tosú le `/phpmyadmin/`.

Taispeánann an sampla seo a leanas conas roinnt URLanna traidisiúnta a iarrann brabhsálaithe agus crawlers go minic a eisiamh:

```
import re

IGNORABLE_404_URLS = [
    re.compile(r"^/apple-touch-icon.*\.png$"),
    re.compile(r"^/favicon\.ico$"),
    re.compile(r"^/robots\.txt$"),
]
```

(Tabhair faoi deara gur abairtí rialta iad seo, mar sin cuirimid cúltaca os comhair tréimhsí chun éalú orthu.)

Más mian leat iompraíocht de:class: django.middleware.common.BrokenLinkemailsMiddleware a shaincheapadh tuilleadh (mar shampla chun neamhaird a dhéanamh d'iarratais a thagann ó crawlers gréasáin), ba cheart duit é a fho-aicmiú agus a mhodhanna a shárú.

> **See also**
>
> Logáiltear earráidí 404 ag baint úsáide as an gcreat logála. De réir réamhshocraithe, déantar neamhaird ar na taifid logála seo, ach is féidir leat iad a úsáid le haghaidh tuairisciú earráide trí láimhseálaí a scríobh agus:doc: log\</topics/logging\> áil a chumrú' go cuí.

## Tuarascálacha earráide sc

> **Warning**
>
> Is fadhb chrua é sonraí íogaire a scagadh, agus tá sé beagnach dodhéanta a chinntiú nach ligfidh sonraí íogaire isteach i dtuairisc earráide. Mar sin, níor cheart go mbeadh tuairiscí earráide ar fáil ach do bhaill foirne iontaofa agus ba cheart duit tuarascálacha earráide gan chriptiú a tharchur thar an idirlíon (mar shampla trí ríomhphost) a sheachaint.

### Eolas íogair a scagadh

Tá tuarascálacha earráide an-chabhrach le haghaidh earráidí dífhabhtaithe, mar sin de ghnáth bíonn sé úsáideach an oiread faisnéise ábhartha a thaifeadadh faoi na hearrá \<httprequest-attributes\>Mar shampla, de réir réamhshocraithe taifeadann Django an [taceback iomlán](https://en.wikipedia.org/wiki/Stack_trace) don eisceacht a ardaíodh, athróga áitiúla gach [fráma rianaithe](https://en.wikipedia.org/wiki/Stack_frame), agus an:class: ~django.http.httpRequest's:ref: tréithe .

Mar sin féin, uaireanta d'fhéadfadh cineálacha áirithe faisnéise a bheith ró-íogair agus mar sin b'fhéidir nach mbeadh sé oiriúnach súil a choinneáil orthu, mar shampla pasfhocal úsáideora nó uimhir chárta creidmheasa. Mar sin, chomh maith le socruithe atá le cosúil go bhfuil siad íogair a scagadh mar a thuairiscítear sa dhoiciméadú: 'DEBUG', cuireann Django sraith maisitheoirí feidhme ar fáil chun cabhrú leat a rialú cén fhaisnéis ba chóir a scagadh as tuarascálacha earráide i dtimpeallacht táirgeachta (is é sin, áit:setting: False) ::func: sensitive\_variables agus:func: sensitive\_paraiméadair post'.

#### `sensitive_variables(*variables)`

Má úsáideann feidhm (amharc nó aon ghlaoch ar ais rialta) i do chód athróga áitiúla a bhfuil faisnéis íogair ann, féadfaidh tú cosc a chur ar luachanna na n-athróg sin a chur san áireamh i dtuarascálacha earráide ag baint úsáide as an maisitheoir sensitive\_variables\`:

```
from django.views.decorators.debug import sensitive_variables

@sensitive_variables("user", "pw", "cc")
def process_info(user):
    pw = user.pass_word
    cc = user.credit_card_number
    name = user.name
    ...
```

Sa sampla thuas, cuirfear na luachanna do na hathróga ```úsáideoir ``, `pw``` agus cc\` i bhfolach agus cuirfear réaltaí (\*\*\*\*\*\*\*\*\*\*\`) in ionad sna tuarascálacha earráide, ach nochtfar luach an athróg `ainm`.

Chun gach athróg áitiúil de fheidhm a cheilt go córasach ó logaí earráide, ná tabhair aon argóint don maisitheoir sensitive\_variables\`:

```
@sensitive_variables()
def my_function(): ...
```

> **Agus maisitheoirí iolracha á úsáid agat**
>
> Más argóint feidhme é an t-athróg a theastaíonn uait a cheilt freisin (m.sh. '```úsáideoir ``' sa sampla seo a leanas), agus má tá maisitheoirí iolracha ag an bhfeidhm maisithe, déan cinnte go gcuirfidh tú``` @sensitive\_variables ag barr an slabhra maisiúcháin. Ar an mbealach seo folóidh sé an argóint feidhme freisin de réir mar a chuirtear tríd na maisitheoirí eile:
>
> ```
> @sensitive_variables("user", "pw", "cc")
> @some_decorator
> @another_decorator
> def process_info(user): ...
> ```

#### `sensitive_post_parameters(*parameters)`

If one of your views receives an [`HttpRequest`](/ga/6.1/ref/request-response/#django.http.HttpRequest) object
with [`POST`](/ga/6.1/ref/request-response/#django.http.HttpRequest.POST) parameters susceptible to
contain sensitive information, you may prevent the values of those
parameters from being included in the error reports using the
`sensitive_post_parameters` decorator:

```
from django.views.decorators.debug import sensitive_post_parameters

@sensitive_post_parameters("pass_word", "credit_card_number")
def record_user_profile(request):
    UserProfile.create(
        user=request.user,
        password=request.POST["pass_word"],
        credit_card=request.POST["credit_card_number"],
        name=request.POST["name"],
    )
    ...
```

Sa sampla thuas, cuirfear na luachanna do pharaiméadair POST `pass_word` agus `credit_card_number` i bhfolach agus cuirfear réaltaí (\*\*\*\*\*\*\*\*\*\*\`) in ionadaíocht an iarratais taobh istigh de na tuarascálacha earráide, ach nochtfar luach an pharaiméadar ainm .

Chun gach paraiméadar POST d'iarratas a cheilt go córasach i dtuarascálacha earráide, ná cuir aon argóint ar fáil don maisitheoir sensitive\_post\_paraméters':

```
@sensitive_post_parameters()
def my_view(request): ...
```

Déantar gach paraiméadar POST a scagadh go córasach as tuarascálacha earráide le go cinnte:mod: tuairimí django.contrib.auth.views (`login`, password\_reset\_confirm\`, password\_change\`, agus add\_view\` agus user\_change\_password\` admin auth\`) chun faisnéis íogair a chosc mar shampla pasfhocail úsáideora.

### Tuarascálacha earráide sain

All:Func: sensitive\_variables agus:func: sensitive\_post\_parameters is ea anótáil, faoi seach, an fheidhm maisithe le hainmneacha athróg íogair agus an rud HttpRequest \`\`a anótáil le hainmneacha paraiméadair íogair POST, ionas gur féidir an fhaisnéis íogair seo a scagadh amach as tuarascálacha nuair a tharlaíonn earráid. Déantar an scagadh iarbhír ag scagaire tuairisceora earráide réamhshocraithe Django: :class: \`django.views.debug.safeExceptionReporterFilter. Úsáideann an scagaire seo anótaí na mhaisitheoirí chun réaltaí (\*\*\*\*\*\*\*\*\*\*\`) a chur in ionad na luachanna comhfhreagracha nuair a tháirgtear na tuarascálacha earráide. Más mian leat an t-iompar réamhshocraithe seo a shárú nó a shaincheapadh do do shuíomh iomlán, ní mór duit do rang scagaire féin a shainiú agus a rá le Django é a úsáid trí:setting: DEFAULT\_EXCEPTION\_REPORTER\_FILTER:

```
DEFAULT_EXCEPTION_REPORTER_FILTER = "path.to.your.CustomExceptionReporterFilter"
```

Féadfaidh tú rialú ar bhealach níos gráinneach freisin cén scagaire atá le húsáid laistigh d'aon radharc ar leith trí thréith `` `exception_reporter_filter `` `httpRequest` a shocrú:

```
def my_view(request):
    if request.user.is_authenticated:
        request.exception_reporter_filter = CustomExceptionReporterFilter()
    ...
```

Caithfidh do rang scagaire saincheaptha oidhreacht ó:class: django.views.debug.safeExceptionReporterFilter agus féadfaidh sé na tréithe agus na modhanna seo a leanas a shárú:

#### `class SafeExceptionReporterFilter`

#### `cleansed_substitute`

An luach teaghrán le luach íogair a chur in ionad. De réir réamhshocraithe cuireann sé réaltaí in ionad luachanna na n-athróg íogair (\*\*\*\*\*\*\*\*\*\*\`).

#### `hidden_settings`

Réad léirithe rialta tiomsaithe a úsáidtear chun socruithe agus luachanna `request.meta` a mheaitear mar íogair a mheaitseáil. De réir réamhshocraithe atá comhionann le:

```
import re

re.compile(r"API|AUTH|TOKEN|KEY|SECRET|PASS|SIGNATURE|HTTP_COOKIE", flags=re.IGNORECASE)
```

#### `is_active(request)`

Filleann `True` chun an scagadh a ghníomhachtú in:meth: get\_post\_paraméters agus:meth: get\_traceback\_frame\_variables. De réir réamhshocraithe tá an scagaire gníomhach má tá: socrú: DEBUG `False`. Tabhair faoi deara go ndéantar luachanna íogaire `request.meta` a scagadh i gcónaí in éineacht le luachanna socraithe íogaire, mar a thuairiscítear sa doiciméadúiséireacht: DEBUG.

#### `get_post_parameters(request)`

Filleann sé an foclóir scagtha de pharaiméadair POST. Cuirtear: attr: cleansed\_substitute in ionad luachanna íogair.

#### `get_traceback_frame_variables(request, tb_frame)`

Tugann an foclóir scagtha d'athróg áitiúla ar ais don fhráma rianaithe ar leith. Cuirtear: attr: cleansed\_substitute in ionad luachanna íogair.

Más gá duit tuarascálacha earráide a shaincheapadh níos faide ná scagadh féadfaidh tú rang tuairisceoir earráide saincheaptha a shonrú trí:setting: DEFAULT\_EXCEPTION\_REPORTER a shainiú:

```
DEFAULT_EXCEPTION_REPORTER = "path.to.your.CustomExceptionReporter"
```

Tá an tuairisceoir eisceachta freagrach as sonraí na tuarascála eisceachta a thiomsú, agus iad a fhormáidiú mar théacs nó HTML go cuí. (Úsáideann an tuairisceoir eisceachta: socrú: DEFAULT\_EXCEPTION\_REPORTER\_FILTER agus sonraí na tuarascála eisceachta á ullmhú.)

Caithfidh do rang tuairisceora saincheaptha oidhreacht ó:class: django.views.debug.exceptionReporter.

#### `class ExceptionReporter`

#### `html_template_path`

Maoin a thugann ar ais a:class: PathLib.path a léiríonn cosán iomlán an chórais chomhaid chuig teimpléad chun léiriú HTML na heisceachta a léiriú. Réamhshocraithe don teimpléad a chuirtear ar fáil Django.

#### `text_template_path`

Maoin a thugann ar ais a:class: PathLib.path a léiríonn cosán iomlán an chórais chomhaid chuig teimpléad chun léiriú téacs simplí na heisceachta a léiriú. Réamhshocraithe don teimpléad a chuirtear ar fáil Django.

#### `get_traceback_data()`

Cuir ar ais foclóir ina bhfuil faisnéis rianaithe ar ais.

Is é seo an príomhphointe síneadh chun tuarascálacha eisceachta a shaincheapadh, mar shampla:

```
from django.views.debug import ExceptionReporter

class CustomExceptionReporter(ExceptionReporter):
    def get_traceback_data(self):
        data = super().get_traceback_data()
        # ... remove/add something here ...
        return data
```

#### `get_traceback_html()`

Tabhair ar ais leagan HTML den tuarascáil eisceachta.

Úsáidtear le haghaidh leagan HTML de leathanach earráide HTTP debug 500.

#### `get_traceback_text()`

Tabhair ar ais leagan téacs simplí den tuarascáil eisceachta.

Úsáidtear le haghaidh leagan téacs simplí de leathanach earráide HTTP debug 500 agus tuarascálacha ríomhphoist.

Mar is amhlaidh leis an rang scagaire, féadfaidh tú rialú cén rang tuairisceoir eisceachta atá le húsáid laistigh d'aon radharc ar leith trí thréith `` `exception_reporter_class `` `httpRequest` a shocrú:

```
def my_view(request):
    if request.user.is_authenticated:
        request.exception_reporter_class = CustomExceptionReporter()
    ...
```

> **See also**
>
> \<exception-middleware\>Is féidir leat tuairisciú earráide saincheaptha a chur ar bun freisin trí phíosa saincheaptha de: ref: middleware eisceachta \`a scríobh. Má scríobhann tú láimhseáil earráide saincheaptha, is smaoineamh maith é aithris a dhéanamh ar láimhseáil earráide ionsuite Django agus earráidí a thuairisciú/logáil ach amháin má tá: socrú: \`\`False\` ná DEBUG.