Online website Optimization tools

  • just-ping.com — Use Just Ping to determine if a particular website or blog is accessible from other countries. Unlike other online ping services that have service in a couple of locations, Just Ping has 30 monitoring stations across the world including Turkey, Egypt and China. If the ping results say 100% Packet Loss, most likely the site is inaccessible from that region.
  • who.is — If you like to know the contact address, email and phone number of the website owner, this free whois lookup service will help. This is a universal lookup service meaning it can simultaneously query the whois database of all popular domain registrars.
  • whoishostingthis.com — Enter the URL of any website and this online service will show you the name of the company where that website is hosted. This may come handl if you need the contact information of the web hosting provider for writing a DMCA Notice or if you are looking to switch web hosts.
  • popuri.us — You can use popuri to estimate the relative popularity of a website on social sites like Twitter, Google+ and Facebook. It also display the Google Pagerank of a website and the Web of Trust matrix.
  • chillingeffects.org — When there’s a copyright related complaint against a website, a copy of that letter is archived in the Chilling Effects database. Anyone can query this public database to know about all the copyright infringement complaints against a particular website.
  • myip.ms — MyIP.ms offers a comprehensive report of any website or I.P. Address. You get to know about the hosting provider, the physical location of a website, the IP Address change history of a website and the DNS information. Netcraft also offers similar reports.
  • ewhois.com — Ewhois, short for enhanced whois lookup, will help you determine other websites of someone. It looks the whois details, the AdSense publisher ID and the Google Analytics code of websites to figure out other web domain that may belong to the same owner. See example.
  • builtwith.com — Use BuiltWith to know the technology stack of any website. It helps you figure out the mail service provider of a domain, the advertising partners, the tracking widgets that are installed on a website and whether the site is using any CDN like Amazon S3 or Google Cloud. See example.
  • semrush.com — If you wish to analyze your competitor’s website, this is tool to go with. SEMrush will help you figure what organic keywords are people using to find a website, what is the site’s traffic and which are the competing websites. See example.
  • whatsmydns.net — When you buy a new domain or switch from one host to another, the DNS records for the domain change and it may take a while to propagate these changes worldwide. WhatsMyDNS check your DNS records from various locations and it can check your domain’s A, CNAME and MX records.
  • modern.ie — This online app will help test your website’s compatibility with various web browsers and detects coding errors that might cause problems. The site is integrated with BrowserStack so you can quickly know how your site looks on different devices and browsers.
  • developers.google.com — Find the Page Speed score of any website on both desktop and mobile devices. The higher this number, the better. The Google tool also offers suggestion on how the score can be improved.
  • ctrlq.org/sandbox — – The AdSense sandbox solves two problems – it shows the various advertisers that are targeting a website and it will also help you figure out if a particular web domain is banned in the AdSense network or not.
  • httparchive.org — The HTTP Archive is a repository of all performance related metrics for a website. It keeps a record of the size of pages, their average load time and the number of failed requests (missing resources) over time. See example.
1 comment:

Website Optimization tools for SEO,sitemap,Mobile,desktop responsive,page speed and performance.

Statement- Type of website Optimization tools

Solution :


  • Online tool to check the website performance:
              1. https://gtmetrix.com/
              2. https://www.webpagetest.org/
              3. https://varvy.com/pagespeed/

  • Online tool check the website performance for mobile and Desktop pages : Page speed tools
             https://developers.google.com/speed/pagespeed/insights/

  • Image Speed test analysis Tools
             https://webspeedtest.cloudinary.com/



  • Mobile page perfomance test tools
       https://search.google.com/test/mobile-friendly 

  • Tools to check SEO for desktop and Mobile Optimization
           For Desktop : https://varvy.com/
           For Mobile   : https://varvy.com/mobile/
       


    • Tools to check Gzip and Keepalive Optimization
              https://varvy.com/tools/gzip/
    • Metatags speed optimization tools
               https://richpreview.com/?url=http://www.goshop.com.my/index.do
    • Tools to check website IPv6 compatible
               https://ipv6prepared.com/?url=http://www.goshop.com.my/index.do
    • Tools to Check online DNS details for any website
               https://showdnsrecords.com/?url=http://www.goshop.com.my/index.do
    • Tools to check online Load Test
                https://loadtestertool.com/?url=http://www.goshop.com.my/index.do
    • Online tool to check IP address
                 https://whatsmyiptool.com/
    • Tools to check Sitemap optimization
                 https://www.giftofspeed.com/check-keep-alive/
                 https://seositecheckup.com/

    • Tools to check mobile responsive
               http://responsivedesignchecker.com/checker.php?
               http://www.websiteresponsivetest.com/?url=www.xe.com#3


    • Tools to check technology of website online
               https://w3techs.com/
               https://builtwith.com/




    5 comments:

    why do we need Seprate storage configuration for segment (node) and datastore(binary) AEM6.4

    statement : Reason to separate Repository separation: Segment /node store and datastore/binary store

    Solution :
    Performance: 
    • In an ideal AEM repository configuration, the segment store will be stored entirely in memory. 
    • Most AEM repositories have a data store which is too large to allow this, therefore we always separate them out.
    • With the segment store stored entirely in RAM, you will see a massive increase in performance. The physical disk (Bare Metal), vDisk(VMware), EBS Volume (AWS) or Managed Disk (Azure) leveraged for the segment store should also be high performance RAID10 storage ideally SSD/Flash based with a sufficient amount of IOPS available.
    • When sizing your AEM application servers, make sure to allocate enough RAM for an appropriate sized Heap, 

    Maintenance: 
    • By splitting the segment store and data store, you then have more flexible options for repository maintenances. 
    • By having a combined repository, the only way to reclaim disk space is is via a tar compaction (or RevisionGC). 
    • This can be a lengthy activity, depending on the number of changes to the repository — and in some AEM versions must be completed with the AEM instance offline.
    • This means specific publishers will be out of the load balancer pool and your author will be offline during the maintenance.
    •  Separating the data store from the segment store allows you to do an online DatastoreGC, which can be very fast and can be done with the instance still up. 
    • In newer AEM versions with repositories under 1TB these maintenance processes — when run regularly (weekly) — can reclaim tens or hundreds of GB in a few seconds or minutes.
    • Additionally, having moved to a split FileDataStore model, you will (on AEM 6.4) be able to take advantage of a new “tail compaction” maintenance task, 
    • which can be run online with even greater frequency, and only compacts data which has been added since the last compaction, giving you the advantage of always having an AEM instance which is lean and performant.

    Storage flexibility: 
    • Separating out the segment store and data store allows you to place each on their own storage media. 
    • Segment stores can be placed on SSD volumes or Flash storage tiers for high performance, while your data store can leverage less expensive lower performance storage.
    • If leveraging AWS for you AEM deployment, you can use S3 for the data store, which is really inexpensive and can be shared between publishers and author, thus reducing storage costs even more. 
    • Splitting these as well as logging onto separate volumes allows simultaneous writes to the different disks, further improving performance and removing potential bottlenecks.


    No comments:

    Enabling Vanity URLs with Adobe Experience Manager



    Statement -  Handling Vanity URLs Using the AEM Dispatcher Module

     Solution:
    • Recent updates to the AEM Dispatcher module (since version 4.1.9 of the module) allow authors to directly control vanity URLs from within the Author UI, and these are automatically pushed out to the publishers, which then expose them to the dispatchers. 

    AEM

     Steps to be followed:
    /0100 { /type "allow" /url "/libs/granite/dispatcher/content/vanityUrls.html" }
    • Add a caching rule to prevent caching of this URL:
    /0001 { /type "deny" /glob
    "/libs/granite/dispatcher/content/vanityUrls.html" }
    • Add the vanity_urls configuration to the farm:
    /vanity_urls {
    /url "/libs/granite/dispatcher/content/vanityUrls.html"
    /file "/tmp/vanity_urls"
    /delay 300
    }

    • Re-start Apache.
    • The file defined at the /file setting is not automatically created/updated at the time interval set at /delay, but only when a request is made that fails the /filter rules of your dispatcher. On fail, it checks to see if the file is there —
    •  if not, it will generate and use it by pulling /libs/granite/dispatcher/content/vanityUrls.html from the publisher. If it is there, and not older than /delay seconds, it will use it. Finally, if it is older than /delay seconds, it will update it from the Publish instance and use it.
    No comments:

    AEM 6.4 Sample Architecture for Hybrid AEM and Sharded Deployment in Rackspace cloud

    Hybrid AEM deployment with Rackspace Private Cloud, separate Bare Metal authors for content and asset management

    aemsept2


    AEM architecture diagram: sharded author with cloud publishers


    aemsept3

    The above diagram represents site with heavy authoring requirements so that it makes sense to shard out individual sites onto their own physical authoring environments. A Solr Cloud cluster plugs into the authors for indexing DAM assets and assisting with the custom authoring UI. The publish tier is served by Rackspace public cloud servers (OpenStack) which can easily be cloned and scaled up and down to meet load demands.

     connectivity between your author instance and Adobe Marketing Cloud




    Reference : https://blog.rackspace.com/sample-architecture-diagrams-for-adobe-experience-manager
    No comments:

    top 10 new features of AEM 6.4


    Statement - AEM 6.4 New Features

     Solution :

     - Powered by Sensei AI - Machine learning platform and Artificial content intelligence, Imp features of AEM are as follows.

     1. Smart crop and imaging :
    •  Adobe Sensei AI machine-learning can identify important elements of an image and intelligently auto-crop and resize images for various layouts, resulting in massive time savings for your creative and content authoring staff.
    • Individually cropping images for various experiences (mobile vs. desktop, portrait vs. landscape, square vs. long-rectangle ad formats, etc.) has traditionally been an excruciatingly labor-intensive part of executing a marketing campaign
    2. Smart layout
    • Smart Layouts also makes use of Adobe Sensei machine learning, as well as data from Adobe Analytics and Adobe Target to automatically build relevant experiences for a given content set.
    • Smart Layouts built a page layout automatically to optimize for a KPI which you select (value per visit, customer lifetime value, subscriber growth rate, etc)
    3. Automatic smart tagging
    • Powered by Adobe Sensei, Smart Tags uses a self-learning algorithm to automatically identify and tag items in your photos — including both generic objects (sky, buildings, clouds, etc.) as well as items specific to your business (i.e. clothing types, automobile models, etc.)


    AEM infrastructure diagram
    4. Style system for web components
    • AEM 6.4 rolls out a new theming system for individual page components to create a consistent look, feel and experience across components or pages — maximizing design flexibility while minimizing development effort.
    • The Style System allows you to create visual variations of web components with zero back-end development.
    5. Experience fragments and integration with Adobe Target
    • With AEM 6.4, users can compose Experience Fragments with Dynamic Media to instantly reassemble fragments upon delivery into layouts that fit any targeted screen size. 
    • This additional capability empowers marketers to add more interactive or engaging experiences like clickable hotspots, videos or product information pop-ups
    6. Adobe Launch integration
    • Adobe Launch (Previously known as Dynamic Tag Management) is an embracive solution for managing all the various tracking codes used across your properties for user behavior tracking, performance and user experience measurement, e-commerce and conversion metrics
    7. Multi language search and reverse search translation memory
    • AEM assets search now has multi-language capability, using Sensei to translate search terms in real time. 
    • Users can enter a keyword in one language, and the Sensei algorithm will translate that keyword instantaneously, searching and delivering matching assets across defined language libraries.
    8. SPA- Single page application editor
    • A groundbreaking new feature for AEM is support for single-page apps written in React.JS or Angular.
    • Whereas content authors trying to edit a single-page application previously would have needed deep Javascript development experience.
    • AEM will be able to import single page applications into the Author environment, allowing content authors to select and modify content areas in the application without having to write any code.
    9. Enhanced maintenance functionality- Tail compaction
    •  AEM 6.4 introduces a new “Tail Compaction” method for reducing disk utilization.
    • AEM 6.4’s Tail Compaction allows one to run a compaction online, and then quickly run a compaction periodically on the “tail” of only those things which have been added and modified in the repository since the last compaction. 
    • This would allow a compaction to be run even several times per DAY as appropriate, thereby keeping all of your AEM instances lean, mean and performant.
    10. Cloud Manager
    Cloud Manager, a feature of Adobe Managed Cloud Services enables organizations to self-manage Experience Manager in the cloud and provides the following benefits:
    • Continuous Integration / Continuous Delivery
    • Code Inspection, performance testing and security validation
    • Automatic, scheduled or manual deployment

    11. AEM Content Fragments & Services
    Content Fragments models are the new visual content model editor and a new configurable component to provide flexible HTML output and JSON to include in content services. It helps create, manage, and deliver structured content to any channel.
    This feature enables authors to create Content Fragments using Content Fragment models.
    12. Enhanced User Experience
    AEM 6.4 has further enhanced the UI to improve user experience as well as to make it easier to use and more productive.
    • New content tree rail
    • Better experience with the search result page
    • New key board shortcuts as well as the ability to disable the shortcuts
    • Stop showing the timestamp for all UI
    • Improved scrolling experience in card and list view of large folders.
    13. AEM Forms Key Features
    The key highlights of the AEM 6.4 Forms release are:
    • Multi-channel Interactive Communications
    • Data Integration enhancements
    • Single-hop upgrade from LiveCycle to Experience Manager Forms 6.4
    • Automated Forms conversions of legacy forms to mobile responsive forms for any device.
    No comments:

    Segment not found/repository inconsistency in AEM 6.3


    Statement : Segment Not found exceptions in AEM 6.3

    ERROR [Apache Sling Repository Startup Thread] o.a.j.o.s.SegmentNotFoundExceptionListener (SegmentNotFoundExceptionListener.java:48) - Segment not found: 559ffeq2weq71-f9f2-4771-a6d7-334b86623f17ed. SegmentId age=2345ms
    o    org.apache.jackrabbit.oak.segment.SegmentNotFoundException: Segment 559f43fe71-f9f2-4771-a6d7-334b866234f17ed not found


    ERROR [Apache Sling Repository Startup Thread] 
    o    org.apache.jackrabbit.oak.segment.SegmentNotFoundException: Segment 559ffe7112-f9f2-4771-a6d7-334b866f1127ed not found
     at org.apache.jackrabbit.oak.segment.file.FileStore$8.call(FileStore.java:6022)
     at org.apache.jackrabbit.oak.segment.file.FileStore$8.call(FileStore.java:5342)

    Solution:  

    •  Download the oak-run-1.x.x.jar version matching with your running instance.
    • Stop the instance and navigate to path of downloadded jar file
    •  Preform the consistency check with below comamnd
                  java -jar oak-run-1.6.x.x.jar check /path/to/crx-                                                                  quickstart/repository/segmentstore
     It will traverse backward to find the good state of the segments.
    • Revert the repository to this revision by editing ./crx-quickstart/repository/segmentstore/journal.log and Remove all lines after the line containing the latest good revision.
    • Delete all ./crx-quickstart/repository/segmentstore/*.bak files.
    • Run checkpoint clean-up to remove orphaned checkpoints: 
                 java -jar oak-run-1.6.x.x.jar checkpoints /path/to/crx-                                                      quickstart/repository/segmentstore rm-unreferenced

    • Finally run the compaction command to compact the repository
                 java -Xmx6000m -jar oak-run-1.6.x.x.jar compact /path/to/crx-                                         quickstart/repository/segmentstore


    Environment  : AEM 6.3  with SP2+CFP1+CFP2 
    No comments:

    Slow Queries Development Tools in AEM

    Query Development Tools

    Adobe Supported

    Community Supported

    • Oak Index Definition Generator
      • Generate optimal Lucence Property Index from XPath or JCR-SQL2 query statements.
    • AEM Chrome Plug-in
      • Google Chrome web browser extension that exposes per-request log data, including executed queries and their query plans, in the browser's dev tools console.
      • Requires Sling Log Tracer 1.0.2+ to be installed and enabled on AEM.
    No comments:

    Troubleshooting Slow Queries in AEM


    Statement: Slow Query Classifications

     Solution :

    Slow Query Classifications
    There are 3 main classifications of slow queries in AEM, listed by severity:
    1. Index-less queries
      • Queries that do not resolve to an index and traverse the JCR's contents to collect results
    2. Poorly restricted (or scoped) queries
      • Queries that resolve to an index, but must traverse all index entries to collect results
    3. Large result set queries
      • Queries that return very large numbers of results.

    Note: 
    • The first 2 classifications of queries (index-less and poorly restricted) are slow, because they force the Oak query engine to inspect each potential result (content node or index entry) to identify which belong in the actual result set. 
    • In AEM 6.3, by default, when a traversal of 100,000 is reached, the query fails and throws an exception. 
    • This limit does not exist by default in AEM versions prior to AEM 6.3, but can be set via the Apache Jackrabbit Query Engine Settings OSGi configuration and QueryEngineSettings JMX bean (property LimitReads).

    1. Detecting Index-less Queries

    During Development
    Explain all queries and ensure their query plans do not contain the /* traverse explanation in them. Example traversing query plan:
    • PLAN: [nt:unstructured] as [a] /* traverse "/content//*" where ([a].[unindexedProperty] = 'some value') and (isdescendantnode([a], [/content])) */

    Post-Deployment
    • Monitor the error.log for index-less traversal queries:
      • *INFO* org.apache.jackrabbit.oak.query.QueryImpl Traversal query (query without index) ... ; consider creating and index
      • This message is only logged if no index is available, and if the query potentially traverses many nodes. Messages are not logged if an index is available, but amount to traversing is small, and thus fast.
    • Visit the AEM Query Performance operations console and Explain slow queries looking for traversal or no index query explanations.

    Query Performance
    The Query Performance page allows the analysis of the slowest queries performed by the system. This information is provided by the repository in a JMX Mbean. 
    In Jackrabbit, the com.adobe.granite.QueryStat JMX Mbean provides this information, while in the Oak repository, it is offered by org.apache.jackrabbit.oak.QueryStats.
    The page displays:
    • The time when the query was made
    • The language of the query
    • The number of times the query was issued
    • The statement of the query
    • The duration in milliseconds


    chlimage_1

    Explain Query
    For any given query, Oak attempts to figure out the best way to execute based on the Oak indexes defined in the repository under the oak:index node.
     Depending on the query, different indexes may be chosen by Oak. Understanding how Oak is executing a query is the first step to optimizing the query.
    The Explain Query is a tool that explains how Oak is executing a query. It can be accessed by going to Tools - Operations - Diagnosis from the AEM Welcome Screen, then clicking on Query Performance and switching over to the Explain Querytab.
    Features
    • Supports the Xpath, JCR-SQL and JCR-SQL2 query languages
    • Reports the actual execution time of the provided query
    • Detects slow queries and warns about queries that could be potentially slow
    • Reports the Oak index used to execute the query
    • Displays the actual Oak Query engine explanation
    • Provides click-to-load list of Slow and Popular queries
    Once you are in the Explain Query UI, all you need to do in order to use it is enter the query and press the Explain button:


    chlimage_1
    The first entry in the Query Explanation section is the actual explanation. The explanation will show the type of index that was used to execute the query.
    The second entry is the execution plan.
    Ticking the Include execution time box before running the query will also show the amount of time the query was executed in, allowing for more information that can be used for optimizing the indexes for your application or deployment.

    chlimage_1

    Detecting Poorly Restricted Queries

    During Development



    Explain all queries and ensure they resolve to an index tuned to match the query's property restrictions.
    • Ideal query plan coverage has indexRules for all property restrictions, and at a minimum for the tightest property restrictions in the query.
    • Queries that sort results, should resolve to a Lucene Property Index with index rules for the sorted by properties that set orderable=true.

    For example, the default cqPageLucene does not have an index rule for jcr:content/cq:tags


    Before adding the cq:tags index rule
    • cq:tags Index Rule
      • Does not exist out of the box
    • Query Builder query
      • type=cq:Page
        property=jcr:content/cq:tags
        property.value=my:tag
    • Query plan
      • [cq:Page] as [a] /* lucene:cqPageLucene(/oak:index/cqPageLucene) *:* where [a].[jcr:content/cq:tags] = 'my:tag' */
    This query resolves to the cqPageLucene index, but because no property index rule exists for jcr:content or cq:tags, when this restriction is evaluated, every record in the cqPageLucene index is checked to determine a match. This means that if the index contains 1 million cq:Page nodes, then 1 million records are checked to determine the result set.
    After adding the cq:tags index rule
    • cq:tags Index Rule
      • /oak:index/cqPageLucene/indexRules/cq:Page/properties/cqTags
        @name=jcr:content/cq:tags
        @propertyIndex=true
    • Query Builder query
      • type=cq:Page
        property=jcr:content/cq:tags
        property.value=myTagNamespace:myTag
    • Query plan
      • [cq:Page] as [a] /* lucene:cqPageLucene(/oak:index/cqPageLucene) jcr:content/cq:tags:my:tag where [a].[jcr:content/cq:tags] = 'my:tag' */
    The addition of the indexRule for jcr:content/cq:tags in the cqPageLucene index allows cq:tags data to be stored in an optimized way.
    When a query with the jcr:content/cq:tags restriction is performed, the index can look up results by value. That means that if 100 cq:Page nodes have myTagNamespace:myTag as a value, only those 100 results are returned, and the other 999,000 are excluded from the restriction checks, improving performance by a factor of 10,000.

    Post-Deployment



    • Monitor the error.log for travesal queries:
      • *WARN* org.apache.jackrabbit.oak.spi.query.Cursors$TraversingCursor Traversed ### nodes ... consider creating an index or changing the query
    • Visit the AEM Query Performance operations console and Explain slow queries looking for query plans that do not resolve query property restrictions to index property rules.


    Detecting Large Result Set Queries


    During Development


    Set low threshholds for oak.queryLimitInMemory (eg. 10000) and oak.queryLimitReads (eg. 5000) and optimize the expensive query when hitting an UnsupportedOperationException saying “The query read more than x nodes..."

    Post-Deployment


    • Monitor the logs for queries triggering large node traversal or large heap memory consumption :
      • *WARN* ... java.lang.UnsupportedOperationException: The query read or traversed more than 100000 nodes. To avoid affecting other tasks, processing was stopped.
      • Optimize the query to reduce the number of traversed nodes
    • Monitor the logs for queries triggering large heap memory consumption :
      • *WARN* ... java.lang.UnsupportedOperationException: The query read more than 500000 nodes in memory. To avoid running out of memory, processing was stopped
      • Optimize the query to reduce the heap memory consumption
    For AEM 6.0 - 6.2 versions, you can tune the threshold for node traversal via JVM parameters in the AEM start script to prevent large queries from overloading the environment. The recommended values are :
    • -Doak.queryLimitInMemory=500000
    • -Doak.queryLimitReads=100000
    In AEM 6.3, the above 2 parameters are preconfigured by default, and can be modified via the OSGi QueryEngineSettings.

    Query Development Tools

    Adobe Supported

    Community Supported


    • Oak Index Definition Generator
      • Generate optimal Lucence Property Index from XPath or JCR-SQL2 query statements.
    • AEM Chrome Plug-in
      • Google Chrome web browser extension that exposes per-request log data, including executed queries and their query plans, in the browser's dev tools console.
      • Requires Sling Log Tracer 1.0.2+ to be installed and enabled on AEM.
    No comments:
    Subscribe to: Posts (Atom)