Questo articolo è per gli autori di plugin presenti nel repository ufficiale di WordPress.
Immagina che la nuova major release del tuo plugin per WordPress abbia un bug grave che non è stato trovato durante i test.
Siamo umani, quindi può succedere.
Se il tuo plugin è installato su migliaia di installazioni, la pressione sul tuo sistema di supporto aumenterà, e rischia di collassare se il team di supporto non è dimensionato bene.
In molti casi, il team di supporto sei solo tu.
Qui ti mostro come cerco di prevenire questo tipo di situazione per Freesoul Deactivate Plugins.
FDP è ancora giovane ma sta crescendo, quindi è meglio pensare in anticipo a tutto ciò che possiamo fare per evitare una pressione troppo alta sul sistema di supporto. E se il tuo plugin è in una situazione simile, o con un numero più alto di installazioni attive, ti suggerisco di pensarci.
Il metodo che sto per mostrarti si basa su poche righe di codice, quindi senza spendere altro tempo o risorse fisiche. Dopo aver implementato il codice, l’aiuto sarà gratuito.
L’idea è fornire un rilascio graduale automatico basato sul rischio di malfunzionamenti dopo l’aggiornamento.
L’idea non è mia. Molte aziende software lo fanno già per software molto diffusi.
Ecco il codice.
define( 'EOS_DP_PLUGIN_BASE_NAME', untrailingslashit( plugin_basename( __FILE__ ) ) );
//Ottiene le informazioni sul plugin
function my_get_plugin_info( $slug ){
$response = wp_remote_get( 'https://api.wordpress.org/plugins/info/1.0/freesoul-deactivate-plugins.json' );
if( !is_wp_error( $response ) ){
$json = wp_remote_retrieve_body( $response );
$info = json_decode( $json );
$return = array();
if( is_object( $info ) ){
$return['threads'] = $info->support_threads;
$return['solved_threads'] = $info->support_threads_resolved;
$return['last_updated'] = $info->last_updated;
$return['versions'] = $info->versions;
return $return;
}
}
return false;
}
add_filter( 'site_transient_update_plugins','my_manage_staged_rollout' );
//Rilascio graduale per le major release in base al rischio di avere problemi
function my_manage_staged_rollout( $value ){
if( defined( 'FDP_STAGED_ROLLOUT' ) && false === FDP_STAGED_ROLLOUT ) return $value;
if( isset( $value ) && is_object( $value ) ){
if( isset( $value->response[EOS_DP_PLUGIN_BASE_NAME] ) ){
$plugin_data = $value->response[EOS_DP_PLUGIN_BASE_NAME];
$new_version = $plugin_data->new_version;
if( substr_count( $new_version,'.' ) < substr_count( EOS_DP_VERSION,'.' ) ){
//È una major release, notifichiamo l'aggiornamento prima alle installazioni con meno rischi di avere problemi
$info = eos_dp_get_plugin_info( 'freesoul-deactivate-plugins' );
if( $info ){
if( isset( $info['last_updated'] ) ){
$last_checked = $value->last_checked;
$active_plugins = array_unique( get_option( 'active_plugins',array() ) );
$need_update = count( $value->response );
$risk = 0;
if( $active_plugins ) $risk = $risk + absint( ( count( $active_plugins ) - 20 ) );
if( $need_update ) $risk = $risk + absint( $need_update );
$unsolved_threads = absint( max( 0,$info['threads'] - $info['solved_threads'] - 10 ) );
$risk = $risk + 10 * $unsolved_threads;
$risk = min( 100,$risk )/10; //dopo 10 giorni dalla pubblicazione della major release, tutti vedranno comunque la notifica di aggiornamento
$since_last_update = time() - strtotime( $info['last_updated'] );
if( $risk > $since_last_update/( 60 * 60 * 24 ) || $since_last_update < 60 * 60 ){
//La notifica di aggiornamento non viene mostrata se il rischio è maggiore del numero di giorni trascorsi dall'ultima major release, o se la pubblicazione della major release è avvenuta meno di 1 ora fa
unset( $value->response[EOS_DP_PLUGIN_BASE_NAME] );
}
}
}
}
}
}
return $value;
}
Se hai letto fin qui, sei un autore di plugin, quindi il codice qui sopra non ha bisogno di molte spiegazioni.
EOS_DP_PLUGIN_BASE_NAME sarà qualcosa che assomiglia a your-plugin-folder-name/your-plugin-main-file-name.php.
Il codice qui sopra funziona se lo scrivi nel file principale del tuo plugin. Nel mondo reale, definirai la costante del basename del plugin nel file principale e le due funzioni saranno incluse in un file PHP che avrai da qualche parte nelle cartelle del tuo plugin, probabilmente all’interno di una classe PHP. Questo dipende da te.
La funzione my_get_plugin_info restituisce un array di informazioni sul plugin. Ovviamente, sostituisci freesoul-deactivate-plugins con lo slug del tuo plugin.
Agganciamo il filtro site_transient_update_plugins con la funzione my_manage_staged_rollout.
All’interno della nostra funzione my_manage_staged_rollout chiediamo prima i dati sull’ultimo aggiornamento del nostro plugin.
Se la nuova versione ufficiale rilevata da WordPress è una major release, andiamo avanti chiedendo le informazioni che ci aiuteranno a calcolare il rischio di malfunzionamenti dopo l’aggiornamento.
Freesoul Deactivate Plugins di solito è installato insieme a decine di altri plugin. In questo caso, preferisco dare un peso importante al numero di plugin installati.
Il rischio di malfunzionamenti è più alto per le installazioni in cui sono installati molti plugin. Quindi gli utenti che hanno molti plugin vedranno la notifica di aggiornamento più tardi rispetto agli utenti con installazioni con meno plugin.
Durante le prime ore e i primi giorni, gli utenti con pochi plugin testeranno la nuova major release in un ambiente a basso rischio e il sistema di supporto rischierà meno pressione all’inizio.
Ma comunque, se un bug grave non è stato rilevato durante i test, qualcuno busserà al tuo sistema di supporto, ma si spera non decine di utenti, come può succedere quando tutti ricevono la notifica di aggiornamento.
Inoltre, il rischio tiene conto anche del numero di thread aperti nel forum di supporto. Se ci sono molti thread irrisolti, il rischio sarà più alto e meno utenti vedranno la notifica di aggiornamento.
Dentro la funzione, diamo un limite di 10 giorni, oltre il quale tutti vedranno la notifica di aggiornamento, e ci assicuriamo che nessuno la veda durante la prima ora dopo la pubblicazione. Questo serve ad avere il tempo di eseguire gli ultimissimi test su una versione che già consideriamo stabile e a mantenere la possibilità di tornare alla versione precedente se salta fuori qualcosa di davvero inatteso.
Ovviamente, sei libero di modificare il calcolo del rischio tenendo conto del tuo caso specifico.
Se vuoi che tutti vedano la notifica di aggiornamento, non assegnare un numero di versione che contenga meno punti della versione ufficiale attuale.
Se ad esempio la versione ufficiale attuale è 1.8.8.6, se pubblichi 1.8.8.7 tutti verranno notificati, ma se pubblichi 1.8.9 si attiverà il rilascio graduale.
Spero che aiuti a prevenire i picchi di richieste sul tuo sistema di supporto dopo le major release.