Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Funzioni di libreria disponibili per gli script canary Python che usano Selenium Questa sezione elenca le funzioni di libreria di Selenium disponibili per gli script canary Python. **Topics** + [Classi e funzioni della libreria Python e Selenium che si applicano a tutti i canary](#CloudWatch_Synthetics_Library_allcanaries_Python) + [Classi e funzioni della libreria Python e Selenium che si applicano solo ai canary dell'interfaccia utente](#CloudWatch_Synthetics_Library_Python_UIcanaries) ## Classi e funzioni della libreria Python e Selenium che si applicano a tutti i canary Le seguenti funzioni della libreria CloudWatch Synthetics Selenium per Python sono utili per tutti i canarini. **Topics** + [SyntheticsConfiguration classe](#CloudWatch_Synthetics_Library_SyntheticsConfiguration_Python) + [SyntheticsLogger classe](#CloudWatch_Synthetics_Library_SyntheticsLogger_Python) ### SyntheticsConfiguration classe È possibile utilizzare la SyntheticsConfiguration classe per configurare il comportamento delle funzioni della libreria Synthetics. Ad esempio, puoi utilizzare questa classe per configurare la funzione ` executeStep()` per non acquisire screenshot. È possibile impostare le configurazioni CloudWatch Synthetics a livello globale. Definizioni della funzione: #### set\$1config(options) ``` from aws_synthetics.common import synthetics_configuration ``` ` options ` è un oggetto, che è un insieme di opzioni configurabili per il tuo canary. Le seguenti sezioni spiegano i campi possibili in ` options `. + `screenshot_on_step_start` (booleano): indica se fare uno screenshot prima di iniziare una fase. + `screenshot_on_step_success` (booleano): indica se acquisire uno screenshot dopo aver completato una fase riuscita. + `screenshot_on_step_failure` (booleano): indica se acquisire uno screenshot dopo il fallimento di una fase. **with\$1screenshot\$1on\$1step\$1start(screenshot\$1on\$1step\$1start)** Accetta un argomento booleano, che indica se eseguire uno screenshot prima di iniziare una fase. **with\$1screenshot\$1on\$1step\$1success(screenshot\$1on\$1step\$1success)** Accetta un argomento booleano, che indica se acquisire uno screenshot dopo aver completato correttamente una fase. **with\$1screenshot\$1on\$1step\$1failure(screenshot\$1on\$1step\$1failure)** Accetta un argomento booleano, che indica se acquisire uno screenshot dopo il fallimento di una fase. **get\$1screenshot\$1on\$1step\$1start()** Restituisce se acquisire uno screenshot prima di iniziare una fase. **get\$1screenshot\$1on\$1step\$1success()** Restituisce se acquisire uno screenshot dopo aver completato correttamente una fase. **get\$1screenshot\$1on\$1step\$1failure()** Restituisce se acquisire uno screenshot dopo che una fase fallisce. **disable\$1step\$1screenshots()** Disabilita tutte le opzioni di screenshot (get\$1screenshot\$1on\$1step\$1start, get\$1screenshot\$1on\$1step\$1success e get\$1screenshot\$1on\$1step\$1failure). **enable\$1step\$1screenshots()** Abilita tutte le opzioni di screenshot (get\$1screenshot\$1on\$1step\$1start, get\$1screenshot\$1on\$1step\$1success e get\$1screenshot\$1on\$1step\$1failure). Per impostazione predefinita, tutti questi metodi sono abilitati. **setConfig (opzioni) relative alle metriche CloudWatch ** Per i canarini che utilizzano `syn-python-selenium-1.1` o versioni successive, le **(options)** di **setConfig** possono includere i seguenti parametri booleani che determinano quali metriche vengono pubblicate dal canarino. Il valore predefinito per ciascuna di queste opzioni è `true`. Le opzioni che iniziano con ` aggregated` determinano se il parametro viene emesso senza destinazione ` CanaryName`. Puoi usare questi parametri per visualizzare i risultati aggregati per tutti i canary. Le altre opzioni determinano se il parametro viene emesso con la dimensione `CanaryName`. Puoi usare questi parametri per visualizzare i risultati per ogni singolo canary. Per un elenco delle metriche emesse dai canarini, vedi CloudWatch . [CloudWatch metriche pubblicate da canaries](CloudWatch_Synthetics_Canaries_metrics.md) + `failed_canary_metric` (booleano): indica se emettere il parametro ` Failed` (con la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `failed_requests_metric` (booleano): indica se emettere il parametro `Failed requests` (con la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `2xx_metric` (booleano): indica se emettere il parametro `2xx` (con la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `4xx_metric` (booleano): indica se emettere il parametro `4xx` (con la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `5xx_metric` (booleano): indica se emettere il parametro `5xx` (con la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `step_duration_metric` (booleano): indica se emettere il parametro `Step duration` (con le dimensioni `CanaryName` `StepName`) per questo canary. Il valore predefinito è `true`. + `step_success_metric` (booleano): indica se emettere il parametro `Step success` (con le dimensioni `CanaryName` `StepName`) per questo canary. Il valore predefinito è `true`. + `aggregated_failed_canary_metric` (booleano): indica se emettere il parametro `Failed` (senza la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `aggregated_failed_requests_metric` (booleano): indica se emettere il parametro `Failed Requests` (senza la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `aggregated_2xx_metric` (booleano): indica se emettere il parametro ` 2xx` (senza la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `aggregated_4xx_metric` (booleano): indica se emettere il parametro ` 4xx` (senza la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. + `aggregated_5xx_metric` (booleano): indica se emettere il parametro ` 5xx` (senza la dimensione `CanaryName`) per questo canary. Il valore predefinito è `true`. **with\$12xx\$1metric(2xx\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `2xx` con dimensione `CanaryName` per questo canary. **with\$14xx\$1metric(4xx\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `4xx` con dimensione `CanaryName` per questo canary. **with\$15xx\$1metric(5xx\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `5xx` con dimensione `CanaryName` per questo canary. **withAggregated2xxMetric(aggregated2xxMetric)** Accetta un argomento booleano, che specifica se emettere un parametro `2xx` senza alcuna dimensione per questo canary. **withAggregated4xxMetric(aggregated4xxMetric)** Accetta un argomento booleano, che specifica se emettere un parametro `4xx` senza alcuna dimensione per questo canary. **with\$1aggregated\$15xx\$1metric(aggregated\$15xx\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `5xx` senza alcuna dimensione per questo canary. **with\$1aggregated\$1failed\$1canary\$1metric (aggregated\$1failed\$1canary\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `Failed` senza alcuna dimensione per questo canary. **con \$1aggregated\$1failed\$1requests\$1metric (aggregated\$1failed\$1requests\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `Failed requests` senza alcuna dimensione per questo canary. **with\$1failed\$1canary\$1metric(failed\$1canary\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `Failed` con dimensione `CanaryName` per questo canary. **with\$1failed\$1requests\$1metric(failed\$1requests\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `Failed requests` con dimensione `CanaryName` per questo canary. **with\$1step\$1duration\$1metric(step\$1duration\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `Duration` con dimensione `CanaryName` per questo canary. **with\$1step\$1success\$1metric(step\$1success\$1metric)** Accetta un argomento booleano, che specifica se emettere un parametro `StepSuccess` con dimensione `CanaryName` per questo canary. ##### Metodi per abilitare o disabilitare i parametri **disable\$1aggregated\$1request\$1metrics()** Disabilita il canary dall'emettere tutti i parametri delle richieste emessi senza dimensione ` CanaryName`. **disable\$1request\$1metrics()** Disabilita tutti i parametri delle richieste, inclusi i parametri dei canary e i parametri aggregati in tutti i canary. **disable\$1step\$1metrics()** Disabilita tutti i parametri dei passaggi, inclusi sia quelli di riuscita che di durata. **enable\$1aggregated\$1request\$1metrics()** Consente al canary di emettere tutti i parametri della richiesta emessi senza la dimensione ` CanaryName`. **enable\$1request\$1metrics()** Abilita tutti i parametri delle richieste, inclusi i parametri dei canary e i parametri aggregati in tutti i canary. **enable\$1step\$1metrics()** Abilita tutti i parametri dei passaggi, inclusi sia quelli di riuscita che di durata. **Utilizzo in canary dell'interfaccia utente** Innanzitutto, importa la dipendenza di Synthetics e recupera la configurazione. Quindi, imposta la configurazione per ogni opzione chiamando il metodo setConfig utilizzando una delle opzioni seguenti. ``` from aws_synthetics.common import synthetics_configuration synthetics_configuration.set_config( { "screenshot_on_step_start": False, "screenshot_on_step_success": False, "screenshot_on_step_failure": True } ) or ``` Oppure ``` synthetics_configuration.with_screenshot_on_step_start(False).with_screenshot_on_step_success(False).with_screenshot_on_step_failure(True) ``` Per disabilitare tutti gli screenshot, usa la funzione () come in questo esempio. disableStepScreenshots ``` synthetics_configuration.disable_step_screenshots() ``` Puoi abilitare e disabilitare gli screenshot in qualsiasi punto del codice. Ad esempio, per disabilitare gli screenshot solo per una fase, disattivali prima di eseguire tale fase e quindi attivali dopo la fase. ##### set\$1config(options) per canary dell'interfaccia utente A partire da `syn-python-selenium-1.1`, per i canary dell'interfaccia utente, ` set_config` può includere i seguenti parametri booleani: + `continue_on_step_failure`**(boolean) — Indica se continuare a eseguire lo script canary dopo un passaggio fallito (si riferisce alla funzione ExecuteStep).** Se le fasi hanno esito negativo, l'esecuzione del canary verrà comunque contrassegnata come fallita. Il valore predefinito è `false`. ### SyntheticsLogger classe `synthetics_logger` scrive i log sia nella console che in un file di log locale allo stesso livello di log. Questo file di log viene scritto in entrambe le posizioni solo se il livello di log è pari o inferiore al livello di registrazione desiderato della funzione di log chiamata. Le istruzioni di registrazione nel file di log locale sono precedute da "DEBUG: ", "INFO: " e così via per corrispondere al livello di log della funzione che è stata chiamata. L'utilizzo di `synthetics_logger` non è necessario per creare un file di log che viene caricato nel percorso dei risultati di Amazon S3. Puoi invece creare un file di log diverso nella cartella `/tmp`. Tutti i file creati nella cartella `/tmp` vengono caricati nella posizione dei risultati nel bucket S3 come artefatti. Per utilizzare `synthetics_logger`: ``` from aws_synthetics.common import synthetics_logger ``` ****Definizioni utili delle funzioni: Ottenere il livello di log: ``` log_level = synthetics_logger.get_level() ``` Impostare il livello di log: ``` synthetics_logger.set_level() ``` Registrare un messaggio con un livello specificato. Il livello può essere `DEBUG`, ` INFO`, `WARN` oppure `ERROR`, come negli esempi di sintassi seguenti: ``` synthetics_logger.debug(message, *args, **kwargs) ``` ``` synthetics_logger.info(message, *args, **kwargs) ``` ``` synthetics_logger.log(message, *args, **kwargs) ``` ``` synthetics_logger.warning(message, *args, **kwargs) ``` ``` synthetics_logger.error(message, *args, **kwargs) ``` Per informazioni sui parametri di debug, consulta la documentazione standard di Python all'indirizzo [logging.debug](https://docs.python.org/3/library/logging.html#logging.debug) In queste funzioni di registrazione, `message` è la stringa di formato del messaggio. `args` sono gli argomenti che vengono uniti in `msg` utilizzando l'operatore di formattazione delle stringhe. Ci sono tre argomenti della parola chiave in `kwargs`: + `exc_info`: se non viene valutato come false (falso), aggiunge informazioni sulle eccezioni al messaggio di log. + `stack_info`: imposta il valore predefinito su false (falso). Se true (vero), aggiunge le informazioni sullo stack al messaggio di log, inclusa la chiamata di registrazione effettiva. + `extra`: il terzo argomento della parola chiave facoltativo, che puoi utilizzare per il passaggio a un dizionario utilizzato per popolare il `__dict__` di `LogRecord` creato per l'evento di log con attributi definiti dall'utente. Esempi: Registrare un messaggio con il livello `DEBUG`: ``` synthetics_logger.debug('Starting step - login.') ``` Registrare un messaggio con il livello `INFO`. `logger.log` è sinonimo di `logger.info`: ``` synthetics_logger.info('Successfully completed step - login.') ``` or ``` synthetics_logger.log('Successfully completed step - login.') ``` Registrare un messaggio con il livello `WARN`: ``` synthetics_logger.warning('Warning encountered trying to publish %s', 'CloudWatch Metric') ``` Registrare un messaggio con il livello `ERROR`: ``` synthetics_logger.error('Error encountered trying to publish %s', 'CloudWatch Metric') ``` Registrare un'eccezione: ``` synthetics_logger.exception(message, *args, **kwargs) ``` Registra un messaggio con il livello `ERROR`. Le informazioni sulle eccezioni vengono aggiunte al messaggio di log. Dovresti chiamare questa funzione solo da un gestore di eccezioni. [Per informazioni sui parametri di eccezione, consulta la documentazione standard di Python all'indirizzo logging.exception](https://docs.python.org/3/library/logging.html#logging.exception) `message` è la stringa di formato del messaggio. `args` sono gli argomenti che vengono uniti in `msg` utilizzando l'operatore di formattazione delle stringhe. Ci sono tre argomenti della parola chiave in `kwargs`: + `exc_info`: se non viene valutato come false (falso), aggiunge informazioni sulle eccezioni al messaggio di log. + `stack_info`: imposta il valore predefinito su false (falso). Se true (vero), aggiunge le informazioni sullo stack al messaggio di log, inclusa la chiamata di registrazione effettiva. + `extra`: il terzo argomento della parola chiave facoltativo, che puoi utilizzare per il passaggio a un dizionario utilizzato per popolare il `__dict__` di `LogRecord` creato per l'evento di registrazione con attributi definiti dall'utente. Esempio: ``` synthetics_logger.exception('Error encountered trying to publish %s', 'CloudWatch Metric') ``` ## Classi e funzioni della libreria Python e Selenium che si applicano solo ai canary dell'interfaccia utente Le seguenti funzioni della libreria CloudWatch Synthetics Selenium per Python sono utili solo per i canari dell'interfaccia utente. **Topics** + [SyntheticsBrowser classe](#CloudWatch_Synthetics_Library_Python_SyntheticsBrowser) + [SyntheticsWebDriver classe](#CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver) ### SyntheticsBrowser classe **Nota** `SyntheticsBrowser` è supportato solo nel browser Chrome. Quando crei un'istanza del browser chiamando `synthetics_webdriver.Chrome()`, l'istanza del browser restituita è del tipo `SyntheticsBrowser`. La ` SyntheticsBrowser` classe eredita la WebDriver classe e fornisce l'accesso a tutti i metodi esposti da. [WebDriver](https://www.selenium.dev/documentation/webdriver/) Controlla e abilita lo script canary per guidare il browser, permettendo a Selenium di funzionare con WebDriver Synthetics. ChromeDriver **Nota** Synthetics sovrascrive il metodo quit per non intraprendere WebDriver [alcuna](https://www.selenium.dev/selenium/docs/api/py/selenium_webdriver_firefox/selenium.webdriver.firefox.webdriver.html) azione. Non è necessario chiudere il browser manualmente, poiché Synthetics se ne occupa automaticamente. Oltre ai metodi standard di Selenium, offre anche i seguenti metodi. **Topics** + [set\$1viewport\$1size(width, height)](#CloudWatch_Synthetics_Library_set_viewport_size) + [save\$1screenshot(filename, suffix)](#CloudWatch_Synthetics_Library_save_screenshot) #### set\$1viewport\$1size(width, height) Imposta l'area di visualizzazione del browser. Esempio: ``` browser.set_viewport_size(1920, 1080) ``` #### save\$1screenshot(filename, suffix) Salva gli screenshot nella directory `/tmp`. Gli screenshot vengono caricati da lì nella cartella degli artefatti del canary nel bucket S3. *filename* è il nome del file per lo screenshot e *suffix* è una stringa opzionale da utilizzare per denominare lo screenshot. Esempio: ``` browser.save_screenshot('loaded.png', 'page1') ``` ### SyntheticsWebDriver classe Per utilizzare questa classe, utilizza i seguenti elementi nello script: ``` from aws_synthetics.selenium import synthetics_webdriver ``` **Topics** + [addExecutionError(errorMessage, ex);](#CloudWatch_Synthetics_Library_Python_addExecutionError) + [add\$1user\$1agent(user\$1agent\$1str)](#CloudWatch_Synthetics_Library_add_user_agent) + [execute\$1step(step\$1name, function\$1to\$1execute)](#CloudWatch_Synthetics_Library_Python_execute_step) + [get\$1http\$1response(url)](#CloudWatch_Synthetics_Library_Python_get_http_response) + [Chrome()](#CloudWatch_Synthetics_Library_Python_Chrome) #### addExecutionError(errorMessage, ex); `errorMessage` descrive l'errore e `ex` è l'eccezione che si verifica Puoi utilizzare `add_execution_error` per impostare gli errori di esecuzione per il tuo canary. Fa fallire il canary senza interrompere l'esecuzione dello script. Inoltre, non influisce sui tuoi parametri `successPercent`. È necessario tenere traccia degli errori come errori di esecuzione solo se non sono importanti per indicare il successo o il fallimento dello script canary. Di seguito è illustrato un esempio dell'uso dell'elemento `add_execution_error`. Stai monitorando la disponibilità del tuo endpoint e acquisendo screenshot dopo che la pagina è stata caricata. Poiché l'errore di acquisizione di uno screenshot non determina la disponibilità dell'endpoint, puoi rilevare eventuali errori riscontrati durante l'acquisizione di screenshot e aggiungerli come errori di esecuzione. I parametri di disponibilità indicheranno comunque che l'endpoint è attivo e funzionante, ma lo stato del canary verrà contrassegnato come non riuscito. Il seguente blocco di codice di esempio rileva tale errore e lo aggiunge come errore di esecuzione. ``` try: browser.save_screenshot("loaded.png") except Exception as ex: self.add_execution_error("Unable to take screenshot", ex) ``` #### add\$1user\$1agent(user\$1agent\$1str) Aggiunge il valore di `user_agent_str` all'intestazione dell'agente utente del browser. È necessario assegnare `user_agent_str` prima di creare l'istanza del browser. Esempio: ``` await synthetics_webdriver.add_user_agent('MyApp-1.0') ``` `add_user_agent` deve essere usato all'interno di una funzione `async`. #### execute\$1step(step\$1name, function\$1to\$1execute) Elabora una funzione. Inoltre esegue le seguenti operazioni: + Registra che il passaggio è iniziato. + Acquisisce uno screenshot denominato `-starting`. + Avvia un timer. + Esegue la funzione fornita. + Se la funzione viene restituita normalmente, conta come passaggio. Se la funzione genera, conta come errore. + Termina il timer. + Registra se il passaggio è riuscito o non è riuscito + Prende uno screenshot chiamato `-succeeded` o ` -failed`. + Emette la metrica `stepName` `SuccessPercent`, 100 per passato o 0 per errore. + Genera il parametro `stepName` `Duration` con un valore basato sull'ora di inizio e di fine del passaggio. + Infine, restituisce ciò che il `functionToExecute` ha restituito o rigenera ciò che `functionToExecute` ha generato. Esempio: ``` from selenium.webdriver.common.by import By def custom_actions(): #verify contains browser.find_element(By.XPATH, "//*[@id=\"id_1\"][contains(text(),'login')]") #click a button browser.find_element(By.XPATH, '//*[@id="submit"]/a').click() await synthetics_webdriver.execute_step("verify_click", custom_actions) ``` #### get\$1http\$1response(url) Effettua una richiesta HTTP all'URL fornito e restituisce il codice di risposta della richiesta HTTP. Se si verifica un'eccezione durante la richiesta HTTP, viene restituita una stringa con valore “error”. Esempio: ``` response_code = syn_webdriver.get_http_response(url) if not response_code or response_code == "error" or response_code < 200 or response_code > 299: raise Exception("Failed to load page!") ``` #### Chrome() Avvia un'istanza del browser Chromium e restituisce l'istanza creata del browser. Esempio: ``` browser = synthetics_webdriver.Chrome() browser.get("https://example.com/) ``` Per avviare un browser in modalità di navigazione in incognito, utilizza quanto segue: ``` add_argument('——incognito') ``` Per aggiungere impostazioni proxy, utilizza quanto segue: ``` add_argument('--proxy-server=%s' % PROXY) ``` Esempio: ``` from selenium.webdriver.chrome.options import Options chrome_options = Options() chrome_options.add_argument("——incognito") browser = syn_webdriver.Chrome(chrome_options=chrome_options) ```