The WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:
Found a bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority.?Create a ticket in the bug tracker.
@adamsilverstein: WebP feature was reverted following Matt’s post. Still trying to determine what a canonical pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party is and if it would work for WebP by default. Still have some fixes to land for 6.1 around image quality when WebPs are output via Performance Lab plugin.
We’ve run out of time to merge before BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1 cutoff
Feedback process was a lot slower than we thought it would be
Should continue to work on this and try to get it in for 6.2
@spacedmonkey: Merging now doesn’t feel great as there are still unanswered questions. Code is ready, but not sure what feedback will push this across the line. May need to push early in 6.2 cycle and see what happens.
@flixos90: Feels like another merge proposal post with a concrete timeline on a merge date could be good to put out right after 6.1, so people can provide any additional feedback. Should also note the new theme support flag approach.
@spacedmonkey: Focusing on dev notesdev noteEach important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include a description of the change, the decision that led to this change, and a description of how developers are supposed to work with that change. Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase. next week
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
@mxbclang: #56040 and #56041 (two Site Health checks from Performance Lab) have been merged for 6.1 and dev notes are in progress
@mukesh27: PR #543 for adding can-load.php to these Health Checks is ready for review
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or ping in Slack
@mxbclang: Reminder about the performance testing environment work started back in March: https://make.wordpress.org/core/2022/03/22/performance-team-meeting-summary-22-march-2022/. This has stalled out since then; if anyone is interested in picking it back up, let us know.
@flixos90: Working on a proposal to integrate the Server Timing API into Performance Lab. We have a lack of awareness for how WP is performing server-side and this simple piece of infrastructure would allow us to measure specific features/modules of the plugin to see who they are affecting PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher performance. Should an open an issue this week or next.
@mehulkaklotar: Continuing to work on a proposal for the plugin performance checker tool
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@masteradhoc: Don’t think a lot of users on older versions would be using a feature plugin, seems like a different target group
@markjaquith: Yeah, suspect that the sites using this plugin are more likely to be using 6.0x and even if not, the goal of the plugin is to move things forward
Options are autoloaded by default, and most options stay autoloaded even after the plugin or theme that uses them has been deactivated
This autoloading has a cost in terms of the performance of the query that loads autoloaded options, and also because the values of these options are kept in memory
Discussed a lot of ways of addressing this at WordCampWordCampWordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. US, and the most promising path that would have the most benefit for the most users (and fits in with this group’s philosophy on focusing on automated fixes instead of introducing new APIs) is to dynamically move options in and out of the “autoload” pool based on usage
Options that are used *and* are not past a certain size cutoff should be autoloaded, but large options and options that are not used, should not be autoloaded
Proof of concept is linked in the ticketticketCreated for both bug reports and feature development on the bug tracker. and we’re looking for additional feedback
@pbearne already brought up the issue of options that are queried BEFORE a module could start “listening” for them to be called, but there are undoubtedly other gotchas and opportunities here
Especially useful would be help in developing a strategy for measuring the performance of this fix for various sizes of autoloaded options
@flixos90: Could leverage the Server Timing APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. (noted above) to measure the time the autoloaded options query takes, for example
@pbearne: Think that both @markjaquith‘s and my fixes can be used as they work best for different configurations
@spacedmonkey: Could we start adding a limit to the number of autoloaded options, say 250 rows? Or is the issue size in terms of memory?
@pbearne: If we can load just what we need, the SQL time is less
@markjaquith: We do this to avoid hundreds of individual queries
@rickjames: Is “autoloading” the thing that PHP can do for include files? I thought it was so slow as to be better to always include everything
@markjaquith: No, this is about quering the wp_options table for autoload = 'yes'
@rickjames: That gets to the lack of adequate indexes for the wp_options table; a simple change can speed up SELECTs
@markjaquith: There’s already an index, it’s more about the volume of data being transferred
@eugenemanuilov: Think we should move from defining which option is autoload-able in the database table to the option registration in WP, so a plugin/theme owner will need to register an option similarly to how settings are registered with register_setting and define whether an option is autoload-able there
@flixos90: Both proposals at a high level have the idea of querying what is needed, but the newer proposal does it globally while still keeping a single place of storage while the latter was aimed at having different “options lists” per template/page. The latter would be great, but it comes with heavy storage implications, so the newer proposal is probably the best place to start since it has no additional storage implications.
@markjaquith: Do think that the issue is data, not rows – evicting autoloaded options could help wtih both
@rmccue: Have run into performance problems with pulling autoloaded options from object cache, so agreed that this is an issue
@markjaquith: Also issue with memcache’s default config being size-limited
@spacedmonkey: Could we use register_settings to define if an option should be autoloaded?
@rmccue: CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. problem is that autoload is true by default, which is what causes issues
@markjaquith: Two approaches – @pbearne optimized for “literally just what this page needs”; my POC was for “never autoload things that aren’t used”
@spacedmonkey: So will we store an array of used options in options table?
@markjaquith: Current implementation only stores timestamp of last calibration, but with some additional storage we could minimize dynamic re-adding of autoloaded options
@rmccue: Autoloading options should minimize DB/cache calls, but not necessarily replace them. The heuristic of what should be autoloaded is key to this proposal.
@markjaquith: To me, it’s “things that are used and aren’t unreasonably large.” Can also honor autoload='no' while not honoring autoload='yes' as chosen by developers.
@spacedmonkey: Don’t love the idea of storing an array of keys. How do you generate the array? What is the average page load?
@rmccue: To move forward, we need a concrete proposal for how the heuristic works. Will look into the networknetwork(versus site, blog) saturation problems we’ve run into get an idea of what “unreasonable” might lok like.
Next steps: @markjaquith will work on detailing the heuristic further in #526 and when it’s ready, we’ll schedule another discussion for a future chat
@pbearne: We could support both by a toggle/filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. setting
@antelaca: Each of the third party solutions are using the same library for SVG sanitization, https://github.com/darylldoyle/svg-sanitizer. Idea is to use the same approach and simplify the implementation a bit using one class.
@adamsilverstein: Some concerns on the original ticketticketCreated for both bug reports and feature development on the bug tracker. about how effective the sanitizer is; are we willing to accept the risk of enabling SVGs? “Static” SVGs implies that there’s a blocked list of tags that’s excluded
@masteradhoc: Yes, but using a sanitizing library makes a lot of sense
@adamsilverstein: Library looks well-tested. Maybe initial approach could enable only SVGs as images.
@mxbclang: General concern seems to be that this is not actually a performance improvement but an improvement to UXUXUser experience in terms of how a site feels it’s performing
@pbearne: Found that it does provide a web vitals boost and believe it’s best practice
@adamsilverstein: Agree that this helps perceived performance; though it may not have a measurable effect, how users experience a site is actually a performance concern so this is a real improvement. Other technical concern was from David about potential bloating of the meta table, which we should respond to directly. @pbearne will reply.
@tillkruess: Focused on getting the Object Cache Site Health test merged into core in https://github.com/WordPress/wordpress-develop/pull/2890 with @furi3r; core developer feedback appreciated
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or ping in Slack
@mxbclang: Reminder about the performance testing environment work started back in March: https://make.wordpress.org/core/2022/03/22/performance-team-meeting-summary-22-march-2022/. This has stalled out since then; if anyone is interested in picking it back up, let us know.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@adamsilverstein: For the preload resources work, proposed a new, more declarative way to specify preloads in https://github.com/WordPress/wordpress-develop/pull/3089; appreciate any feedback.
@olliejones: There’s a Site Health and Troubleshooting plugin, and similar but not identical functionality in core. Is there any plan to incorporate that pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party into core? Or do Performance Lab modules need to target both environments?
@mxbclang: Someone manages that plugin, but not sure who; might be worth asking in the #meta channel
We’ll follow the process previously used by the coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. team, outlined here
Bethany will add a nominations post to https://make.wordpress.org/performance/ this week
@adamsilverstein: Working to complete several follow-up patches for WebP support. A couple of small fixes were committed last week, and the remaining patches are on track to land in the next week. The Pull Requests section at the top of https://core.trac.wordpress.org/ticket/55443 is a good way to check progress, since follow-up patches are boing worked on in PRs linked to this ticketticketCreated for both bug reports and feature development on the bug tracker..
@mukeshpanchal27: Working on:
Core patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. follow-up – WebP compatibility: add fallback for non-supporting browsers to core – PR #3034 ready for review
Enhance JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. replacement mechanism for WebP to JPEG to more reliably replace full file name – Merged in pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party
@erikyo: Noting that WebP conversion feature currently only works for JPGs, but in the future hope to also use PNG with Performance Lab and maybe a way to filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. the input format is needed
@adamsilverstein: If you used the mapping to create WebP from PNG uploads, the replacement code won’t work. We should be able to address, though our initial implementation is focused on JPEG > WebP. @erikyo will comment on the linked PR for further discussion.
@mehulkaklotar: Working on core patches for WebP uploads, ready for review: https://github.com/WordPress/wordpress-develop/pull/3030 and https://github.com/WordPress/wordpress-develop/pull/3048. Also working on https://core.trac.wordpress.org/ticket/45471 to allow caching of parse_blocks results.
@tillkruess: Merged two PRs last week: https://github.com/wordPress/wordpress-develop/pull/2967 and https://github.com/WordPress/wordpress-develop/pull/2969
@pbearne: Not sure where the dominant color proposal is going, do we have the support to get it into core? Want to make sure it’s moving along
@flixos90 to review PRs this week, but welcome others too, as well: https://github.com/WordPress/wordpress-develop/pull/2907 https://github.com/WordPress/wordpress-develop/pull/2906
@itmapl: Interested in resolving https://core.trac.wordpress.org/ticket/32052; PR is here: https://github.com/WordPress/WordPress/pull/610. Open to comments on the solution so we can move forward.
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
Asking to move Object Cache Check to Async test. Should we do this on the plugin level first and then move it to core, or directly there?
@mxbclang: Thinking we should update in the plugin first, then port to the core PR once it’s merged; @flixos90 agrees
Use of custom filters, instead of using site_status_test_result filter.=
Asking to remove the color scheme we have used for alerts (green, yellow, green), and instead use same one for label (performance uses blue)
@adamsilverstein: Looks like valuable feedback on the PRs, suggest keep working there with @clorith and others to find a good solution
@olliejones: Still looking at the SQL database health checks. Pretty sure we can check for misconfigured/slow/ancient MySQLMySQLMySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/./MariaDB, but none of this is actionable by a site owner. Do we want to proceed with health checks that aren’t actionable by “typical” users?
@mxbclang: Based on our discussion last week, seems like no – we want to focus on health checks that are actionable by typical (i.e. not developers, not ops people) users
@olliejones: Is there any way to move forward with MySQL optimization work in a way that can make it to core eventually?
Have a bunch of SQL server tests that say “ask your hosting provider to…” – should we abandon those?
@mxbclang: Those are okay because they provide an action that anyone can take, asking their hosting provider@flashusb agrees
@zero4281: Does the Health Check module have hooksHooksIn WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. to add in additional more advanced health checks? If it did, Ollie could add those checks to his custom plugin
@flashusb: Yes, there is a hook to add custom checks, not a separate tab though
@furi3r: Agree we should expand Site Health use to more technical users, maybe a new tab? If we want to achieve bigger results, we shouldn’t limit ourselves
@ankitgade: Could be a separate tab, something like “Advanced Site Health Check”
@olliejones: Would be great to find a way to address these MySQL optimization issues, maybe the Woo team should address it?
@johnbillion: Did you move the MySQL optimization work to your plugin?
@olliejones: Yes, been in the plugin for over a year now. Can add custom health checks just like Yoast did.
@johnbillion: Think the best approach is to continue work in the plugin, including the health checks, and propose any changes that need to be made in core to facilitate them
@olliejones: There are possible core changes but they’re very difficult to pull off because many users are still stuck on MySQL 5.5
@johnbillion: Happy to review the plugin and help create performance benchmarks for the changes
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or ping in Slack
@mxbclang: Reminder about the performance testing environment work started back in March: https://make.wordpress.org/core/2022/03/22/performance-team-meeting-summary-22-march-2022/. This has stalled out since then; if anyone is interested in picking it back up, let us know.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@adamsilverstein: Resource preloading landed in https://core.trac.wordpress.org/ticket/42438. Some follow-up work for this work includes considering a more declarative APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. (currently it is implemented as a filter) and first party usage, e.g. applying preload to core resources in both wp-adminadmin(and super admin) and (core) themes
@flixos90: Notable PR is https://github.com/WordPress/performance/pull/458, which enhances plugin uninstall to better support multisite. Next Performance Lab 1.4.0 will be released on Monday; please finalize any PRs by tomorrow.
@mxbclang: I’ll be offline on medical leave August 22 through September 9; please ping @flixos90 or @mukesh27 during that time if you need help with anything
@alaca: Would like to discuss possible approaches. The idea to allow only static XML files for now is great, but I think we can do more – which depends on the approach we want to take when detecting the dynamic file. Two possible approaches:
1) We have a list of keywords that shouldn’t be in the document, we can just check that, and prevent document upload if we find something inside the document
2) Parse the document to see what’s in there, but then we have an opportunity to do more, such as sanitization.
@alaca: Each one of the third party solutions out there is using the same library for SVG sanitization; it’s great and battle tested. Want to use the same approach and simplify the implementation a bit with one simple class.
@olliejones: Are there exploit vulnerabilities stemming from parsing XML?
@masteradhoc: Want to be able to upload any SVGs that I have and have WP sanitize them for me if there’s an issue
@erikyo: I use a completely different approach in https://github.com/erikyo/OH-MY-SVG; they aren’t stored in the Media Library, but there are advantages like being able to edit them
@masteradhoc: Think not having them in the Media Library would be confusing
@erikyo: If they’re stored in the Media Library they can be processed by ImageMagick
@mxbclang: Performance bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. scrub will be held Wednesday, August 3, 2022 at 11am EDT
WebP compatibility: add fallback for non-supporting browsers to core – PR #3034 ready for review
Add the new source data to the media REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. endpoint – PR #3025 merged in WordPress core
Add the original image’s extension to the WebP file name to ensure it is unique – PR #444 need final review
Enhance JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. replacement mechanism for WebP to JPEG to more reliably replace full file name – PR #443 need final review
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or ping in Slack
@mxbclang: Reminder about the performance testing environment work started back in March: https://make.wordpress.org/core/2022/03/22/performance-team-meeting-summary-22-march-2022/. This has stalled out since then; if anyone is interested in picking it back up, let us know.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@olliejones: Proposing a total of eight separate health checks that cover a variety of database issues; more details and mockups here. These would all be in one single module.
@mxbclang: Any issues with having these all in one module as opposed to separate, as we’ve done previously with health checks?
@adamsilverstein: Not an issue, but concerned about the recommendations for adding keys and if they would be actionable by users
@olliejones: The add-keys actions are presented as WP-CLIWP-CLIWP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/https://make.wordpress.org/cli/ commands with a copy-to-clipboard function
@adamsilverstein: Right, but what percentage of WP users know what WP-CLI is and use it?
@masteradhoc: Important to describe these very well as they’ll be hard for everyone to understand
@mukeshpanchal27: Are there other ways to add keys outside of CLICLICommand Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress.?
@olliejones: I have a pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party that does this re-keying
@mxbclang: Unfortunately we can’t point users there
@olliejones: What about a separate module for the health checks that generate CLI commands?
@adamsilverstein: Goal here is to build features for core, which means they have to help the majority (80%+) of users, so anything that is specifically for very large sites or uses CLI is plugin territory, not core
@zero4281: Since query speed is dictated by rows in a table, can we only display a health check if a site has a certain number of posts/rows?
@mxbclang: Since everything in Performance Lab should eventually be merged into core, the CLI-related health checks probably should not be in this plugin
@adamsilverstein: Focus on the existing warning to make sure it is “site owner” targeted and maybe drop the keys check entirely. For the advanced part, maybe create a concise guide for the developer handbook to cover important approaches
Could be in https://wordpress.org/support/article/optimization/#database-tuning or perhaps on our Performance site
@seedsca: What is wrong with WP-CLI? It’s a great tool
@adamsilverstein: Agreed, it’s just that it’s not something an average WP user knows about or how to use
@mxbclang: Next step is for @olliejones to revise the proposal to indicate which checks would be included/removed to proceed. Once that update has been made, we can discuss again in a future chat.
@mxbclang: Performance bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. scrub will be held Wednesday, August 3, 2022 at 11am EDT
@adamsilverstein: Main WebP work has been merged to core! TicketticketCreated for both bug reports and feature development on the bug tracker. is still open because there are several small follow-up patches we’re working on
CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. follow-up: WebP compatibility: add fallback for non-supporting browsers to cor and Add the new source data to the media REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. endpoint – PR #3025
Add the original image’s extension to the WebP file name to ensure it is unique – PR #444
Enhance JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. replacement mechanism for WebP to JPEG to more reliably replace full file name – PR #443
@mehulkaklotar: Working on core patch for support of multiple mime types on image edit/restore flows. PR link
@joegrainger: Looking to create a new Settings screen to allow administrators to regenerate images to help with performance. Also creating background infrastructure to handle long-running tasks which will be used by the regenerate images job. This will allow users to regenerate images to the correct sizes when changing a theme and to create WebP versions of older images too.
@pbearne: Hoping that the background processing infrastructure is open for calling by other plugins, a bit like scheduling a cron task
@joegrainger: That’s the plan; the background processing infrastructure is decoupled from the regeneration of images, so it can be used by other plugins for running their own background jobs
@zero4281: Love the idea of being able to regenerate images at the click of a button. Has anyone given thought to updating GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ once the picture tagtagA directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.), image srcset, and image regeneration is complete? In theory it should be possible to remove the need for the user to select an image size and just include all image sizes in the srcset and let the web browser choose the size.
@flixos90: Great points; updating Gutenberg editor content would be a potential use case for the background process. With image size selection, there’s still value depending on how you place the image.
@zero4281: Doesn’t Gutenberg define the width and height in the image tag?
@flixos90: If the user resizes it, but by default, it takes dimensions from the image size selected
@joegrainger: Took a lot of inspiration from this pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party and made some changes, but background processing infrastructure will work similar to this
Received 7 thumbs up votes to proceed with this module, so we’ll get started
@flixos90: Make sure to develop this in a feature branchbranchA directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch". as it will be quite large
@spacedmonkey: Might also be useful for dominant color as well, to backfill old images
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
@furi3r: Working on Site Health TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. ticket feedback; not much, so hopefully will be able to merge soon
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or ping in Slack
@mxbclang: Reminder about the performance testing environment work started back in March: https://make.wordpress.org/core/2022/03/22/performance-team-meeting-summary-22-march-2022/. This has stalled out since then; if anyone is interested in picking it back up, let us know.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@mxbclang: Our new blog is live at https://make.wordpress.org/performance/! How should we use this moving forward?
@flixos90: Thinking we continue to post meeting notes, etc. on CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. and cross-post them to Performance
@pbearne: Could we use it for articles about performance best practices?
@flixos90: Main purpose is to have a single entry point for everything and a handbook for onboarding and best practices
@flashusb: Could we have an Email Updates widgetWidgetA WordPress Widget is a small block that performs a specific function. You can add these widgets in sidebars also known as widget-ready areas on your web page. WordPress widgets were originally created to provide a simple and easy-to-use way of giving design and structure control of the WordPress theme to the user. like the other blogs?
@ollliejones: Can it serve as a place for “more details” articles or site health check results?
@flixos90: More about contributing to the team and what the team is doing
Moving forward, we’ll continue to post agenda and notes on the Core blog and cross-post to Performance
@mxbclang will draft a sticky post for the Performance blog and look into an email updates widget in the sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme.
@adamsilverstein: Finishing up work on the WebP/multi-mime type feature; @flixos90 has reviewed and added several new tests on the PR. Also updated the patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. on the Trac ticket and would welcome feedback. Planning to commit later this week and once it lands there are already several follow-up pieces that are being worked on and need review. Also a few bugs related to WebP planned to review: https://core.trac.wordpress.org/ticket/54476 and https://core.trac.wordpress.org/ticket/53669
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
@spacedmonkey: How long do we wait for feedback? https://github.com/WordPress/wordpress-develop/pull/2890 has been approved by two core committers so could be merged ASAP
@flixos90: We’re not in a massive rush, wait 2 more weeks for feedback and then merge
@spacedmonkey: Won’t be around, so someone else will need to merge
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@flixos90: Published 1.3.0 yesterday and broke 7k active installs for the Performance Lab pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party
@mukesh27: How about a weekly Bug Scrub for the performance channel for performance-focused TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets? We have a total of 326 right now
@mxbclang: Was this intended to be a weekly scheduled meeting?
@spacedmonkey: There are lots of core issues that are impossible to fix in the plugin and need to be fixed in core
@flixos90: Yeah, probably most Trac tickets should be fixed directly as core patches; only tickets that need to be implemented as bigger features should become plugin modules. Always depends on whether core has the necessary integration points to handle that or not.
@mxbclang: Weekly may be tough, how about monthly? Let’s start with the first Wednesday of the month at our regular meeting time, so our first one would be August 3, 2022, at 15:00 UTC
@mehulkaklotar: Merged Remove backup sources & sizes files when attachment deleted #411 for 1.3.0 and coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. updates for WebP
PRs: https://github.com/WordPress/wordpress-develop/pull/2906 and https://github.com/WordPress/wordpress-develop/pull/2907
@flixos90: Working with @adamsilverstein to finalize the foundation core patch for additional MIME types/WebP: https://github.com/WordPress/wordpress-develop/pull/2393. Main thing to add is more test coverage. Plan to commit this week.
@spacedmonkey: Code review needed for https://github.com/WordPress/wordpress-develop/pull/2684, https://github.com/WordPress/wordpress-develop/pull/2967, and https://github.com/WordPress/wordpress-develop/pull/2478
Reviewed https://github.com/WordPress/wordpress-develop/pull/2969 and https://github.com/WordPress/wordpress-develop/pull/2836
Believe that https://github.com/WordPress/wordpress-develop/pull/2478 is ready to go, would like to commit early and handle edge cases with follow-up issues
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
@spacedmonkey: Approved https://github.com/WordPress/wordpress-develop/pull/2890 and so has another core committer; are we waiting to commit until the blog post goes live?
@flixos90: Yes, should definitely publish a post before committing anything. Are the PRs linked in the post?
@flixos90: Have to follow up on comments, but overall very supportive. Some concerns about enforcing coding standards/styles, which we won’t do, so will reply to those; then we can come up with a design and infrastructure build and starting coding. Already worked on a proof of concept here: https://github.com/felixarntz/plugin-check
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@flixos90: 1.3.0 release is on Monday; there are several open PRs for it that should be completed/merged by EOD tomorrow or else they may need to go to the next release
@masteradhoc: This is one of the bigger achievable pain points that I see in WP, as the vectorized format is quite popular for logos, icons, and illustrations. SVG is widely supported and has been for some time. A lot of concerns have been raised in the original Trac ticket about this in terms of security, as SVGs could include scripts, which is a security concern. The proposal only allows for SVGs to be uploaded if they do not contain scripts.
@spacedmonkey: The Images folks are correctly focused on WebP conversion and dominant color. Once those are in core, the team Images team can focus on it, with a 6.2 merge at the earliest. SVG has a lot of benefits but you upload them at your own risk. Need to ensure that SVGs are stripped of inline scripts and maybe even animations.
@flixos90: Agreed that supporting any scripting should be avoided, especially to start
@spacedmonkey: My code for Web Stories SVGs is open source: https://github.com/GoogleForCreators/web-stories-wp/blob/main/includes/Media/SVG.php, using this library: https://github.com/darylldoyle/svg-sanitizer
@flixos90: Supportive of a Performance Lab module for this. Given that there are reliable approaches out there already for stripping scripts from SVGs, would be realistic to get this as a module fairly quickly and then get some testing. 6.2 for core merge would be a realistic goal.
@flixos90: Would https://github.com/darylldoyle/svg-sanitizer be compatible with core in terms of licensing, PHP version support, etc?
@spacedmonkey: Has a GNU general public license, would need to be loaded into core and maintained
@flixos90: How large is the codebase and how complex is the code that actually sanitizes the SVG?
@spacedmonkey: 25k, but 4k of that is the readme; it is complex
@mxbclang: Sounds like we’re all in favor of moving forward! @masteradhoc will get started working on concept, testing, and administration, but will need some deeper code knowledge – just let us know when you need us.
TLDR; We made WordPress packages publishing to npm more predictable by synchronizing it with bi-weekly GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party RC1 release. We no longer have to keep the process tightly coupled with WordPress major releases.
Revised branching strategy for npm publishing
The Gutenberg repository still follows the WordPress SVN repository’s branching strategy for every major WordPress release. In addition to that, there are two other special branches that control npm publishing workflows and they are used as follows:
The wp/latestbranchbranchA directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch". contains the same version of packages as those published to npm with the latest distribution tagtagA directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.). The goal here is to have this branch synchronized with the last Gutenberg plugin release, and the only exception would be unplanned Standalone Bugfix Package Releases (read more below).
The wp/next branch contains the same version of packages as those published to npm with the next distribution tag. It always gets synchronized with the trunk branch. Projects should use those packages for development or testing purposes only.
A Gutenberg branch wp/* (example wp/6.0) targeting a specific WordPress major releasemajor releaseA release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope. (including its further minor increments) gets created based on the wp/latest Gutenberg branch just after the last Gutenberg release planned for inclusion in the next major WordPress release.
Release types and their schedule:
Synchronizing Gutenberg Plugin (latest dist tag) – publishing happens automatically every two weeks based on the newly created release/* (example release/12.8) branch with the RC1 version of the Gutenberg plugin.
WordPress Releases (patch dist tag) – publishing gets triggered manually from the wp/* (example wp/6.0) branch. Once we reach the point in the WordPress major release cycle (usually after BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1) where we only cherry-pick commits from the Gutenberg repository to the WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress., we use wp/* branch (created from wp/latest) for npm publishing with the patch dist-tag. It’s also possible to use older branches to backportbackportA port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. bugs or security fixes to the corresponding older versions of WordPress Core.
Development Releases (next dist tag) – it is also possible to perform development releases at any time when there is a need to test the upcoming changes.
There is also an option to perform Standalone Bugfix Package Releases at will. It should be reserved only for critical bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes or security releases that must be published to npm outside of regular cycles.
The complete documentation is available in the BlockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. Editor Handbook.
Running npm publishing with GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ workflows
While the npm publishing got configured to happen automatically every two weeks as part of the Gutenberg plugin release workflow, there might still be cases when other release types need to be executed. To start the process, go to Gutenberg’s GitHub repository’s Actions tab, and locate the “Publish npm packages” action. Note the blue banner that says “This workflow has a workflow_dispatch event trigger.”, and expand the “Run workflow” dropdown on its right-hand side.
There are three ways to publish packages to npm depending on the their type:
WordPress major release – select wp from the “Release type” dropdown and enter X.Y (example 5.9) in the “WordPress major release” input field.
Development release – select development from the “Release type” dropdown and leave “WordPress major release” input field empty.
Bugix release – select bugfix from the “Release type” dropdown and leave “WordPress major release” input field empty.
Finally, press the green “Run workflow” button. It triggers the npm publishing job, which needs then to be approved by a Gutenberg Core team member.
Testing JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/. code from a specific major WordPress version
An interesting bonus got included with the revised workflow for npm publishing related to WordPress major releases. It’s now possible to quickly install a version of the individual WordPress package used with a given WordPress version using distribution tags (example for WordPress 5.8.x):
npm install @wordpress/block-editor@wp-5.8
It’s also possible to update all WordPress packages in the project with a single command:
@akshitsethi: Working on Only replace content images with additional MIME type version when in a frontend request context by default #379 and making changes to pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party integration points PR to slightly modify the approach as per Adam’s comment
@mehulkaklotar: Working on Remove backup sources & sizes files when attachment deleted #411 and coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. updates for WebP
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@spacedmonkey: Wondering if anyone would be interested in Convert heic to a web safe image form #53645? It’s the default format that iPhone cameras save to; wondering if we can make it web safe. A good first step might be to convert these files and then work out the kinks.
@masteradhoc: We deal with this a lot. Lots of people connect their phones to Mac or Windows and drag and drop their pictures to a folder, then upload to WP.
@johnbillion: The WP app on iPhone auto-converts HEIC to JPEG on the device before upload
@spacedmonkey: If you send a HEIC via email or upload via a file input, iOSiOSThe operating system used on iPhones and iPads. converts it to a web safe JPEG, but if you upload or drag in MacOS, it doesn’t convert
@codekraft: Imagemagick can support it but it needs libheif
@gilzow: The WebP conversion is specifically for performance; building something for one OS that’s not for optimization seems a bit too narrow and outside of the scope of this group
@johnbillion: Seems like a good fit for a standalone feature pluginFeature PluginA plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins.
@mxbclang: Agreed, seems like this is out of scope for our group but could still be very useful
@mxbclang: Putting the finishing touches on a blogblog(versus network, site) post following up on WebP for new uploads, including our research on the concerns from the community as well as as our adjusted approach and next steps
Also working on some of the core patch changes for WebP uploads; feel free to review
@spacedmonkey: Added unit tests and bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes to Optimize computing dominant color and transparency for images by combining the two functions #381 and approved. Will be working on coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. proposal for dominant color over the next few weeks.
@spacedmonkey: Also been contacting hosting companies and asking about object cache implementations. There are a number of hosts who don’t have the latest improvements to object caching like wp_cache_get_multiple. Been contacting them and advising them about the performance improvements that would come with implementation. Implementation eamples: https://github.com/Automattic/wp-memcached/pull/88 and https://github.com/Automattic/wp-memcached/pull/87; recommend Redis Object Cache plugin for Redis
We’re seeking 1-2 POCs for this group; if you’re interested, please comment here or pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.
@furi3r: Working on porting Full Page Cache and Persistent Object Cache Health Checks to core in https://github.com/WordPress/performance/issues/391 and drafted proposal post here for review; also pinged the Site Health maintainers to keep them in the loopLoopThe Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop.
JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.
@olliejones: One factor to keep in mind is MySQLMySQLMySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/./MariaDB version
@flixos90: New infrastructure is primarily checking to see if something is in and loading via core, so it shouldn’t be loaded via the pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party – but it’s agnostic, so it could check those things
@spacedmonkey: Should we run PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher unit tests against different versions of PHP?
@flixos90: Good question, worth opening an issue about
@flixos90: Suggest opening an issue to work on it, then we can expand the test coverage for Dominant Color accordingly. Maybe not for every PHP version as that would make tests take a very long time, but we could do certain versions (e.g. 5.6, 7.4, 8.1).
@olliejones: Request reviews of the proposal, specifically the Decisions to make section:
Unlike other modules, this one needs at least some dashboard user interface, to initiate the reindexing of the tables, and to complain if the tables use legacy storage features (MyISAM, COMPACT row format). Where do we put that user interface panel?
Experience shows that the POC plugin’s wp-cliWP-CLIWP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/https://make.wordpress.org/cli/ access is necessary on large sites to do the reindexing without timeouts. Should performance lab get wp-cli access? How about using WP_Cron?
What should the module do on multisitemultisiteUsed to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site installations?
@olliejones: This is a bit different from the existing plugin modules because it initiates an operation that might run for a long time – several minutes on a big site. WP-CLI has been very useful in proof-of-concept plugin and could use advice on how to proceed. Wonder if this should be run by the hosting community?
@spacedmonkey: Worth sharing with the hosting community channel?
@flixos90: Adding a UIUIUser interface shouldn’t be a concern for a Performance Lab module; Site Health is almost all UI. Feels like UI would probably be under Tools somewhere. Would it be technically possible to do this spread out through multiple web requests?
@spacedmonkey: Might need Site Health warning saying indexes are not in place
@olliejones: There’s a single ALTER TABLE SQL statement for each table and we need to add/drop all indexes in a single statement. Slowest/biggest table is usually postmeta.
@flixos90: How long would executing this query typically take? If too long, can this SQL statement be sent in a non-blocking way for the PHP process?
@olliejones: Overall, a few minutes for a postmeta table with a couple of megarows. PHP’s SQL support doesn’t have any fire-and-forget or threading that I know about.
@flixos90: If that’s true, not sure this would be feasible for core given they take so long to execute. My concern would be PHP timeout. If SQL execution takes several minutes, an AJAX request won’t work for most sites.
@flixos90: Realistically we wouldn’t be able to send an AJAX request and in that request complete the execution of the SQL statement?
@olliejones: AJAX and/or WP Cron might work, but the AJAX request won’t finish until after ALTER TABLE finishes
@pbearne: For core these could run only for new sites and be worth it
@spacedmonkey: Could adding indexes to new sites be a start?
@flixos90: If we can determine support on site creation and do it only for new sites as applicable, could still be beneficial without having those concerns from slow SQL queries
@furi3r: How does WooCommerce do it? They run big DB updates on upgrades
@olliejones: AFAIK, they’re in batches, but we can’t do that for reindexing
@spacedmonkey: See this as two problems: old sites vs. new sites. Changing schema for newly created sites is more simple
@olliejones: Agreed, but old sites are the ones that have the huge pain points
@olliejones: Plugin already has the WP-CLI stuff, could that be put into a Performance Lab module?
@flixos90: Since Performance Lab is for future core features, a WP-CLI command doesn’t qualify. Would potentially be a good contribution for the WP-CLI project, though. If we want to build something into core, it needs to work through what core offers, e.g. UI-triggered, AJAX, Cron, etc.
You must be logged in to post a comment.